Author: sebb
Date: Thu Mar  6 18:24:48 2008
New Revision: 634504

URL: http://svn.apache.org/viewvc?rev=634504&view=rev
Log:
Regular Expression Extractor now deletes all stale variables from previous 
matches.

Modified:
    
jakarta/jmeter/trunk/src/components/org/apache/jmeter/extractor/RegexExtractor.java
    
jakarta/jmeter/trunk/test/src/org/apache/jmeter/extractor/TestRegexExtractor.java
    jakarta/jmeter/trunk/xdocs/changes.xml

Modified: 
jakarta/jmeter/trunk/src/components/org/apache/jmeter/extractor/RegexExtractor.java
URL: 
http://svn.apache.org/viewvc/jakarta/jmeter/trunk/src/components/org/apache/jmeter/extractor/RegexExtractor.java?rev=634504&r1=634503&r2=634504&view=diff
==============================================================================
--- 
jakarta/jmeter/trunk/src/components/org/apache/jmeter/extractor/RegexExtractor.java
 (original)
+++ 
jakarta/jmeter/trunk/src/components/org/apache/jmeter/extractor/RegexExtractor.java
 Thu Mar  6 18:24:48 2008
@@ -140,6 +140,17 @@
                                x++;
                        } while (x != matchNumber && !done);
 
+            int prevCount = 0;
+            String prevString = vars.get(refName + REF_MATCH_NR);
+            if (prevString != null) {
+                vars.remove(refName + REF_MATCH_NR);// ensure old value is not 
left defined
+                try {
+                    prevCount = Integer.parseInt(prevString);
+                } catch (NumberFormatException e1) {
+                    log.warn("Could not parse "+prevString+" "+e1);
+                }
+            }
+            int matchCount=0;// Number of refName_n variable sets to keep
                        try {
                                MatchResult match;
                                if (matchNumber >= 0) {// Original match 
behaviour
@@ -148,38 +159,29 @@
                                                vars.put(refName, 
generateResult(match));
                                                saveGroups(vars, refName, 
match);
                                        } else {
-                        vars.remove(refName + "_g"); // $NON-NLS-1$
-                        vars.remove(refName + "_g0"); // $NON-NLS-1$
-                        vars.remove(refName + "_g1"); // $NON-NLS-1$
-                        //TODO - remove other groups if present?
+                                           // refname has already been set to 
the default (if present)
+                                           removeGroups(vars, refName);
                     }
                                } else // < 0 means we save all the matches
                                {
-                                       int prevCount = 0;
-                                       String prevString = vars.get(refName + 
REF_MATCH_NR);
-                                       if (prevString != null) {
-                                               try {
-                                                       prevCount = 
Integer.parseInt(prevString);
-                                               } catch (NumberFormatException 
e1) {
-                            log.warn("Could not parse "+prevString+" "+e1);
-                                               }
-                                       }
-                                       vars.put(refName + REF_MATCH_NR, "" + 
matches.size());// Save the count
-                                       for (int i = 1; i <= matches.size(); 
i++) {
+                    removeGroups(vars, refName); // remove any single matches
+                                   matchCount = matches.size();
+                                       vars.put(refName + REF_MATCH_NR, 
Integer.toString(matchCount));// Save the count
+                                       for (int i = 1; i <= matchCount; i++) {
                                                match = 
getCorrectMatch(matches, i);
                                                if (match != null) {
-                                                       vars.put(refName + 
UNDERSCORE + i, generateResult(match));
-                                                       saveGroups(vars, 
refName + UNDERSCORE + i, match);
+                                   final String refName_n = new 
StringBuffer(refName).append(UNDERSCORE).append(i).toString();
+                            vars.put(refName_n, generateResult(match));
+                                                       saveGroups(vars, 
refName_n, match);
                                                }
                                        }
-                                       for (int i = matches.size() + 1; i <= 
prevCount; i++) {
-                                               vars.remove(refName + 
UNDERSCORE + i);
-                        // Remove known groups
-                                               vars.remove(refName + 
UNDERSCORE + i + "_g0"); // $NON-NLS-1$
-                                               vars.remove(refName + 
UNDERSCORE + i + "_g1"); // $NON-NLS-1$
-                                               // TODO remove other groups if 
present?
-                                       }
                                }
+                               // Remove any left-over variables
+                for (int i = matchCount + 1; i <= prevCount; i++) {
+                    final String refName_n = new 
StringBuffer(refName).append(UNDERSCORE).append(i).toString();
+                    vars.remove(refName_n);
+                    removeGroups(vars, refName_n);
+                }
                        } catch (RuntimeException e) {
                                log.warn("Error while generating result");
                        }
@@ -188,19 +190,64 @@
                }
        }
 
+       /**
+        * Creates the variables:<br/>
+        * basename_gn, where n=0...# of groups<br/>
+        * basename_g = number of groups (apart from g0)
+        */
        private void saveGroups(JMeterVariables vars, String basename, 
MatchResult match) {
                StringBuffer buf = new StringBuffer();
         buf.append(basename);
         buf.append("_g"); // $NON-NLS-1$
         int pfxlen=buf.length();
+        String prevString=vars.get(buf.toString());
+        int previous=0;
+        if (prevString!=null){
+            try {
+                previous=Integer.parseInt(prevString);
+            } catch (NumberFormatException e) {
+                log.warn("Could not parse "+prevString+" "+e);                
+            }
+        }
         //Note: match.groups() includes group 0
-               for (int x = 0; x < match.groups(); x++) {
+               final int groups = match.groups();
+        for (int x = 0; x < groups; x++) {
                        buf.append(x);
                        vars.put(buf.toString(), match.group(x));
                        buf.setLength(pfxlen);
                }
-        vars.put(buf.toString(), Integer.toString(match.groups()-1));
+        vars.put(buf.toString(), Integer.toString(groups-1));
+        for (int i = groups; i <= previous; i++){
+            buf.append(i);
+            vars.remove(buf.toString());// remove the remaining _gn vars
+            buf.setLength(pfxlen);            
+        }
        }
+
+    /**
+     * Removes the variables:<br/>
+     * basename_gn, where n=0...# of groups<br/>
+     * basename_g = number of groups (apart from g0)
+     */
+    private void removeGroups(JMeterVariables vars, String basename) {
+        StringBuffer buf = new StringBuffer();
+        buf.append(basename);
+        buf.append("_g"); // $NON-NLS-1$
+        int pfxlen=buf.length();
+        // How many groups are there?
+        int groups;
+        try {
+            groups=Integer.parseInt(vars.get(buf.toString()));
+        } catch (NumberFormatException e) {
+            groups=0;
+        }
+        vars.remove(buf.toString());// Remove the group count
+        for (int i = 0; i <= groups; i++) {
+            buf.append(i);
+            vars.remove(buf.toString());// remove the g0,g1...gn vars
+            buf.setLength(pfxlen);
+        }
+    }
 
        public Object clone() {
                RegexExtractor cloned = (RegexExtractor) super.clone();

Modified: 
jakarta/jmeter/trunk/test/src/org/apache/jmeter/extractor/TestRegexExtractor.java
URL: 
http://svn.apache.org/viewvc/jakarta/jmeter/trunk/test/src/org/apache/jmeter/extractor/TestRegexExtractor.java?rev=634504&r1=634503&r2=634504&view=diff
==============================================================================
--- 
jakarta/jmeter/trunk/test/src/org/apache/jmeter/extractor/TestRegexExtractor.java
 (original)
+++ 
jakarta/jmeter/trunk/test/src/org/apache/jmeter/extractor/TestRegexExtractor.java
 Thu Mar  6 18:24:48 2008
@@ -28,9 +28,6 @@
 import org.apache.jmeter.threads.JMeterContextService;
 import org.apache.jmeter.threads.JMeterVariables;
 
-/**
- * @version $Revision$
- */
 public class TestRegexExtractor extends TestCase {
                RegexExtractor extractor;
 
@@ -155,14 +152,28 @@
                public void testVariableExtraction5() throws Exception {
                        extractor.setRegex("<value 
field=\"(pinposition\\d+)\">(\\d+)</value>");
                        extractor.setTemplate("$1$");
-                       extractor.setMatchNumber(-1);
+                       extractor.setMatchNumber(1);// Set up the non-wild 
variables
                        extractor.process();
-                       assertEquals("3", vars.get("regVal_matchNr"));
+            assertNotNull(vars.get("regVal"));
+                       assertEquals("2",vars.get("regVal_g"));
+            assertNotNull(vars.get("regVal_g0"));
+            assertNotNull(vars.get("regVal_g1"));
+            assertNotNull(vars.get("regVal_g2"));
+
+            extractor.setMatchNumber(-1);
+            extractor.process();
+            assertNotNull(vars.get("regVal"));// Should not clear this?
+            assertNull(vars.get("regVal_g"));
+            assertNull(vars.get("regVal_g1"));
+            assertNull(vars.get("regVal_g2"));
+            assertEquals("3", vars.get("regVal_matchNr"));
                        assertEquals("pinposition1", vars.get("regVal_1"));
                        assertEquals("pinposition2", vars.get("regVal_2"));
                        assertEquals("pinposition3", vars.get("regVal_3"));
+            assertEquals("2", vars.get("regVal_1_g"));
                        assertEquals("pinposition1", vars.get("regVal_1_g1"));
                        assertEquals("1", vars.get("regVal_1_g2"));
+            assertEquals("6", vars.get("regVal_3_g2"));
                        assertEquals("<value field=\"pinposition1\">1</value>", 
vars.get("regVal_1_g0"));
                        assertNull(vars.get("regVal_4"));
 
@@ -171,10 +182,28 @@
                        extractor.process();
                        assertEquals("2", vars.get("regVal_matchNr"));
                        assertEquals("position", vars.get("regVal_1"));
+            assertEquals("1", vars.get("regVal_1_g"));
+            assertEquals("position", vars.get("regVal_1_g1"));
+            assertNull("Unused variables should be null", 
vars.get("regVal_1_g2"));
                        assertEquals("invalidpin", vars.get("regVal_2"));
+            assertEquals("1", vars.get("regVal_2_g"));
+            assertEquals("invalidpin", vars.get("regVal_2_g1"));
+            assertNull("Unused variables should be null", 
vars.get("regVal_2_g2"));
+            assertEquals("1", vars.get("regVal_1_g"));
                        assertNull("Unused variables should be null", 
vars.get("regVal_3"));
+            assertNull("Unused variables should be null", 
vars.get("regVal_3_g"));
                        assertNull("Unused variables should be null", 
vars.get("regVal_3_g0"));
                        assertNull("Unused variables should be null", 
vars.get("regVal_3_g1"));
+            assertNull("Unused variables should be null", 
vars.get("regVal_3_g2"));
+
+            // Check when match fails
+            extractor.setRegex("xxxx(.)(.)");
+            extractor.process();
+            assertEquals("0", vars.get("regVal_matchNr"));
+            assertNull("Unused variables should be null", 
vars.get("regVal_1"));
+            assertNull("Unused variables should be null", 
vars.get("regVal_1_g0"));
+            assertNull("Unused variables should be null", 
vars.get("regVal_1_g1"));
+            assertNull("Unused variables should be null", 
vars.get("regVal_1_g2"));
                }
 
                public void testVariableExtraction7() throws Exception {

Modified: jakarta/jmeter/trunk/xdocs/changes.xml
URL: 
http://svn.apache.org/viewvc/jakarta/jmeter/trunk/xdocs/changes.xml?rev=634504&r1=634503&r2=634504&view=diff
==============================================================================
--- jakarta/jmeter/trunk/xdocs/changes.xml (original)
+++ jakarta/jmeter/trunk/xdocs/changes.xml Thu Mar  6 18:24:48 2008
@@ -89,6 +89,7 @@
 <li>Capture Tidy console error output and log it</li>
 <li>Fix problems using Tidy(tolerant parser) in XPath Assertion and XPath 
Extractor</li>
 <li>Bug 44374 - improve timer calculation</li>
+<li>Regular Expression Extractor now deletes all stale variables from previous 
matches.</li>
 </ul>
 
 <h4>Improvements</h4>



---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]

Reply via email to