src/com/sun/org/apache/regexp/internal/RETest.java - platform/external/jetbrains/jdk8u_jaxp - Git at Google

 /*
  * reserved comment block
  * DO NOT REMOVE OR ALTER!
  */
 /*
  * Copyright 1999-2004 The Apache Software Foundation.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.sun.org.apache.regexp.internal;

 import java.io.BufferedReader;
 import java.io.FileReader;
 import java.io.InputStreamReader;
 import java.io.PrintWriter;
 import java.io.File;
 import java.io.ByteArrayOutputStream;
 import java.io.ObjectOutputStream;
 import java.io.ByteArrayInputStream;
 import java.io.ObjectInputStream;
 import java.io.StringBufferInputStream;
 import java.io.StringReader;
 import java.io.IOException;

 /**
  * Data driven (and optionally interactive) testing harness to exercise regular
  * expression compiler and matching engine.
  *
  * @author <a href="mailto:jonl@muppetlabs.com">Jonathan Locke</a>
  * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
  * @author <a href="mailto:gholam@xtra.co.nz">Michael McCallum</a>
  */
 public class RETest
 {
     // True if we want to see output from success cases
     static final boolean showSuccesses = false;

     // A new line character.
     static final String NEW_LINE = System.getProperty( "line.separator" );

     // Construct a debug compiler
     REDebugCompiler compiler = new REDebugCompiler();

     /**
      * Main program entrypoint.  If an argument is given, it will be compiled
      * and interactive matching will ensue.  If no argument is given, the
      * file RETest.txt will be used as automated testing input.
      * @param args Command line arguments (optional regular expression)
      */
     public static void main(String[] args)
     {
         try
         {
             if (!test( args )) {
                 System.exit(1);
             }
         }
         catch (Exception e)
         {
             e.printStackTrace();
             System.exit(1);
         }
     }

     /**
      * Testing entrypoint.
      * @param args Command line arguments
      * @exception Exception thrown in case of error
      */
     public static boolean test( String[] args ) throws Exception
     {
         RETest test = new RETest();
         // Run interactive tests against a single regexp
         if (args.length == 2)
         {
             test.runInteractiveTests(args[1]);
         }
         else if (args.length == 1)
         {
             // Run automated tests
             test.runAutomatedTests(args[0]);
         }
         else
         {
             System.out.println( "Usage: RETest ([-i] [regex]) ([/path/to/testfile.txt])" );
             System.out.println( "By Default will run automated tests from file 'docs/RETest.txt' ..." );
             System.out.println();
             test.runAutomatedTests("docs/RETest.txt");
         }
         return test.failures == 0;
     }

     /**
      * Constructor
      */
     public RETest()
     {
     }

     /**
      * Compile and test matching against a single expression
      * @param expr Expression to compile and test
      */
     void runInteractiveTests(String expr)
     {
         RE r = new RE();
         try
         {
             // Compile expression
             r.setProgram(compiler.compile(expr));

             // Show expression
             say("" + NEW_LINE + "" + expr + "" + NEW_LINE + "");

             // Show program for compiled expression
             PrintWriter writer = new PrintWriter( System.out );
             compiler.dumpProgram( writer );
             writer.flush();

             boolean running = true;
             // Test matching against compiled expression
             while ( running )
             {
                 // Read from keyboard
                 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
                 System.out.print("> ");
                 System.out.flush();
                 String match = br.readLine();

                 if ( match != null )
                 {
                     // Try a match against the keyboard input
                     if (r.match(match))
                     {
                         say("Match successful.");
                     }
                     else
                     {
                         say("Match failed.");
                     }

                     // Show subparen registers
                     showParens(r);
                 }
                 else
                 {
                     running = false;
                     System.out.println();
                 }
             }
         }
         catch (Exception e)
         {
             say("Error: " + e.toString());
             e.printStackTrace();
         }
     }

     /**
      * Exit with a fatal error.
      * @param s Last famous words before exiting
      */
     void die(String s)
     {
         say("FATAL ERROR: " + s);
         System.exit(-1);
     }

     /**
      * Fail with an error. Will print a big failure message to System.out.
      *
      * @param log Output before failure
      * @param s Failure description
      */
     void fail(StringBuffer log, String s)
     {
         System.out.print(log.toString());
         fail(s);
     }

     /**
      * Fail with an error. Will print a big failure message to System.out.
      *
      * @param s Failure description
      */
     void fail(String s)
     {
         failures++;
         say("" + NEW_LINE + "");
         say("*******************************************************");
         say("*********************  FAILURE!  **********************");
         say("*******************************************************");
         say("" + NEW_LINE + "");
         say(s);
         say("");
         // make sure the writer gets flushed.
         if (compiler != null) {
             PrintWriter writer = new PrintWriter( System.out );
             compiler.dumpProgram( writer );
             writer.flush();
             say("" + NEW_LINE + "");
         }
     }

     /**
      * Say something to standard out
      * @param s What to say
      */
     void say(String s)
     {
         System.out.println(s);
     }

     /**
      * Dump parenthesized subexpressions found by a regular expression matcher object
      * @param r Matcher object with results to show
      */
     void showParens(RE r)
     {
         // Loop through each paren
         for (int i = 0; i < r.getParenCount(); i++)
         {
             // Show paren register
             say("$" + i + " = " + r.getParen(i));
         }
     }

     /*
      * number in automated test
      */
     int testCount = 0;

     /*
      * Count of failures in automated test
      */
     int failures = 0;

     /**
      * Run automated tests in RETest.txt file (from Perl 4.0 test battery)
      * @exception Exception thrown in case of error
      */
     void runAutomatedTests(String testDocument) throws Exception
     {
         long ms = System.currentTimeMillis();

         // Some unit tests
         testPrecompiledRE();
         testSplitAndGrep();
         testSubst();
         testOther();

         // Test from script file
         File testInput = new File(testDocument);
         if (! testInput.exists()) {
             throw new Exception ("Could not find: " + testDocument);
         }

         BufferedReader br = new BufferedReader(new FileReader(testInput));
         try
         {
             // While input is available, parse lines
             while (br.ready())
             {
                 RETestCase testcase = getNextTestCase(br);
                 if (testcase != null) {
                     testcase.runTest();
                 }
             }
         }
         finally
         {
             br.close();
         }

         // Show match time
         say(NEW_LINE + NEW_LINE + "Match time = " + (System.currentTimeMillis() - ms) + " ms.");

         // Print final results
         if (failures > 0) {
             say("*************** THERE ARE FAILURES! *******************");
         }
         say("Tests complete.  " + testCount + " tests, " + failures + " failure(s).");
     }

     /**
      * Run automated unit test
      * @exception Exception thrown in case of error
      */
     void testOther() throws Exception
     {
         // Serialization test 1: Compile regexp and serialize/deserialize it
         RE r = new RE("(a*)b");
         say("Serialized/deserialized (a*)b");
         ByteArrayOutputStream out = new ByteArrayOutputStream(128);
         new ObjectOutputStream(out).writeObject(r);
         ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
         r = (RE)new ObjectInputStream(in).readObject();
         if (!r.match("aaab"))
         {
             fail("Did not match 'aaab' with deserialized RE.");
         } else {
             say("aaaab = true");
             showParens(r);
         }

         // Serialization test 2: serialize/deserialize used regexp
         out.reset();
         say("Deserialized (a*)b");
         new ObjectOutputStream(out).writeObject(r);
         in = new ByteArrayInputStream(out.toByteArray());
         r = (RE)new ObjectInputStream(in).readObject();
         if (r.getParenCount() != 0)
         {
             fail("Has parens after deserialization.");
         }
         if (!r.match("aaab"))
         {
             fail("Did not match 'aaab' with deserialized RE.");
         } else {
             say("aaaab = true");
             showParens(r);
         }

         // Test MATCH_CASEINDEPENDENT
         r = new RE("abc(\\w*)");
         say("MATCH_CASEINDEPENDENT abc(\\w*)");
         r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
         say("abc(d*)");
         if (!r.match("abcddd"))
         {
             fail("Did not match 'abcddd'.");
         } else {
             say("abcddd = true");
             showParens(r);
         }

         if (!r.match("aBcDDdd"))
         {
             fail("Did not match 'aBcDDdd'.");
         } else {
             say("aBcDDdd = true");
             showParens(r);
         }

         if (!r.match("ABCDDDDD"))
         {
             fail("Did not match 'ABCDDDDD'.");
         } else {
             say("ABCDDDDD = true");
             showParens(r);
         }

         r = new RE("(A*)b\\1");
         r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
         if (!r.match("AaAaaaBAAAAAA"))
         {
             fail("Did not match 'AaAaaaBAAAAAA'.");
         } else {
             say("AaAaaaBAAAAAA = true");
             showParens(r);
         }

         r = new RE("[A-Z]*");
         r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
         if (!r.match("CaBgDe12"))
         {
             fail("Did not match 'CaBgDe12'.");
         } else {
             say("CaBgDe12 = true");
             showParens(r);
         }

         // Test MATCH_MULTILINE. Test for eol/bol symbols.
         r = new RE("^abc$", RE.MATCH_MULTILINE);
         if (!r.match("\nabc")) {
             fail("\"\\nabc\" doesn't match \"^abc$\"");
         }
         if (!r.match("\rabc")) {
             fail("\"\\rabc\" doesn't match \"^abc$\"");
         }
         if (!r.match("\r\nabc")) {
             fail("\"\\r\\nabc\" doesn't match \"^abc$\"");
         }
         if (!r.match("\u0085abc")) {
             fail("\"\\u0085abc\" doesn't match \"^abc$\"");
         }
         if (!r.match("\u2028abc")) {
             fail("\"\\u2028abc\" doesn't match \"^abc$\"");
         }
         if (!r.match("\u2029abc")) {
             fail("\"\\u2029abc\" doesn't match \"^abc$\"");
         }

         // Test MATCH_MULTILINE. Test that '.' does not matches new line.
         r = new RE("^a.*b$", RE.MATCH_MULTILINE);
         if (r.match("a\nb")) {
             fail("\"a\\nb\" matches \"^a.*b$\"");
         }
         if (r.match("a\rb")) {
             fail("\"a\\rb\" matches \"^a.*b$\"");
         }
         if (r.match("a\r\nb")) {
             fail("\"a\\r\\nb\" matches \"^a.*b$\"");
         }
         if (r.match("a\u0085b")) {
             fail("\"a\\u0085b\" matches \"^a.*b$\"");
         }
         if (r.match("a\u2028b")) {
             fail("\"a\\u2028b\" matches \"^a.*b$\"");
         }
         if (r.match("a\u2029b")) {
             fail("\"a\\u2029b\" matches \"^a.*b$\"");
         }
     }

     private void testPrecompiledRE()
     {
         // Pre-compiled regular expression "a*b"
         char[] re1Instructions =
         {
             0x007c, 0x0000, 0x001a, 0x007c, 0x0000, 0x000d, 0x0041,
             0x0001, 0x0004, 0x0061, 0x007c, 0x0000, 0x0003, 0x0047,
             0x0000, 0xfff6, 0x007c, 0x0000, 0x0003, 0x004e, 0x0000,
             0x0003, 0x0041, 0x0001, 0x0004, 0x0062, 0x0045, 0x0000,
             0x0000,
         };

         REProgram re1 = new REProgram(re1Instructions);

         // Simple test of pre-compiled regular expressions
         RE r = new RE(re1);
         say("a*b");
         boolean result = r.match("aaab");
         say("aaab = " + result);
         showParens(r);
         if (!result) {
             fail("\"aaab\" doesn't match to precompiled \"a*b\"");
         }

         result = r.match("b");
         say("b = " + result);
         showParens(r);
         if (!result) {
             fail("\"b\" doesn't match to precompiled \"a*b\"");
         }

         result = r.match("c");
         say("c = " + result);
         showParens(r);
         if (result) {
             fail("\"c\" matches to precompiled \"a*b\"");
         }

         result = r.match("ccccaaaaab");
         say("ccccaaaaab = " + result);
         showParens(r);
         if (!result) {
             fail("\"ccccaaaaab\" doesn't match to precompiled \"a*b\"");
         }
     }

     private void testSplitAndGrep()
     {
         String[] expected = {"xxxx", "xxxx", "yyyy", "zzz"};
         RE r = new RE("a*b");
         String[] s = r.split("xxxxaabxxxxbyyyyaaabzzz");
         for (int i = 0; i < expected.length && i < s.length; i++) {
             assertEquals("Wrong splitted part", expected[i], s[i]);
         }
         assertEquals("Wrong number of splitted parts", expected.length,
                      s.length);

         r = new RE("x+");
         expected = new String[] {"xxxx", "xxxx"};
         s = r.grep(s);
         for (int i = 0; i < s.length; i++)
         {
             say("s[" + i + "] = " + s[i]);
             assertEquals("Grep fails", expected[i], s[i]);
         }
         assertEquals("Wrong number of string found by grep", expected.length,
                      s.length);
     }

     private void testSubst()
     {
         RE r = new RE("a*b");
         String expected = "-foo-garply-wacky-";
         String actual = r.subst("aaaabfooaaabgarplyaaabwackyb", "-");
         assertEquals("Wrong result of substitution in \"a*b\"", expected, actual);

         // Test subst() with backreferences
         r = new RE("http://[\\.\\w\\-\\?/~_@&=%]+");
         actual = r.subst("visit us: http://www.apache.org!",
                          "1234<a href=\"$0\">$0</a>", RE.REPLACE_BACKREFERENCES);
         assertEquals("Wrong subst() result", "visit us: 1234<a href=\"http://www.apache.org\">http://www.apache.org</a>!", actual);

         // Test subst() with backreferences without leading characters
         // before first backreference
         r = new RE("(.*?)=(.*)");
         actual = r.subst("variable=value",
                          "$1_test_$212", RE.REPLACE_BACKREFERENCES);
         assertEquals("Wrong subst() result", "variable_test_value12", actual);

         // Test subst() with NO backreferences
         r = new RE("^a$");
         actual = r.subst("a",
                          "b", RE.REPLACE_BACKREFERENCES);
         assertEquals("Wrong subst() result", "b", actual);

         // Test subst() with NO backreferences
         r = new RE("^a$", RE.MATCH_MULTILINE);
         actual = r.subst("\r\na\r\n",
                          "b", RE.REPLACE_BACKREFERENCES);
         assertEquals("Wrong subst() result", "\r\nb\r\n", actual);
     }

     public void assertEquals(String message, String expected, String actual)
     {
         if (expected != null && !expected.equals(actual)
             || actual != null && !actual.equals(expected))
         {
             fail(message + " (expected \"" + expected
                  + "\", actual \"" + actual + "\")");
         }
     }

     public void assertEquals(String message, int expected, int actual)
     {
         if (expected != actual) {
             fail(message + " (expected \"" + expected
                  + "\", actual \"" + actual + "\")");
         }
     }

     /**
      * Converts yesno string to boolean.
      * @param yesno string representation of expected result
      * @return true if yesno is "YES", false if yesno is "NO"
      *         stops program otherwise.
      */
     private boolean getExpectedResult(String yesno)
     {
         if ("NO".equals(yesno))
         {
             return false;
         }
         else if ("YES".equals(yesno))
         {
             return true;
         }
         else
         {
             // Bad test script
             die("Test script error!");
             return false; //to please javac
         }
     }

     /**
      * Finds next test description in a given script.
      * @param br <code>BufferedReader</code> for a script file
      * @return strign tag for next test description
      * @exception IOException if some io problems occured
      */
     private String findNextTest(BufferedReader br) throws IOException
     {
         String number = "";

         while (br.ready())
         {
             number = br.readLine();
             if (number == null)
             {
                 break;
             }
             number = number.trim();
             if (number.startsWith("#"))
             {
                 break;
             }
             if (!number.equals(""))
             {
                 say("Script error.  Line = " + number);
                 System.exit(-1);
             }
         }
         return number;
     }

     /**
      * Creates testcase for the next test description in the script file.
      * @param br <code>BufferedReader</code> for script file.
      * @return a new tescase or null.
      * @exception IOException if some io problems occured
      */
     private RETestCase getNextTestCase(BufferedReader br) throws IOException
     {
         // Find next re test case
         final String tag = findNextTest(br);

         // Are we done?
         if (!br.ready())
         {
             return null;
         }

         // Get expression
         final String expr = br.readLine();

         // Get test information
         final String matchAgainst = br.readLine();
         final boolean badPattern = "ERR".equals(matchAgainst);
         boolean shouldMatch = false;
         int expectedParenCount = 0;
         String[] expectedParens = null;

         if (!badPattern) {
             shouldMatch = getExpectedResult(br.readLine().trim());
             if (shouldMatch) {
                 expectedParenCount = Integer.parseInt(br.readLine().trim());
                 expectedParens = new String[expectedParenCount];
                 for (int i = 0; i < expectedParenCount; i++) {
                     expectedParens[i] = br.readLine();
                 }
             }
         }

         return new RETestCase(this, tag, expr, matchAgainst, badPattern,
                               shouldMatch, expectedParens);
     }
 }

 final class RETestCase
 {
     final private StringBuffer log = new StringBuffer();
     final private int number;
     final private String tag; // number from script file
     final private String pattern;
     final private String toMatch;
     final private boolean badPattern;
     final private boolean shouldMatch;
     final private String[] parens;
     final private RETest test;
     private RE regexp;

     public RETestCase(RETest test, String tag, String pattern,
                       String toMatch, boolean badPattern,
                       boolean shouldMatch, String[] parens)
     {
         this.number = ++test.testCount;
         this.test = test;
         this.tag = tag;
         this.pattern = pattern;
         this.toMatch = toMatch;
         this.badPattern = badPattern;
         this.shouldMatch = shouldMatch;
         if (parens != null) {
             this.parens = new String[parens.length];
             for (int i = 0; i < parens.length; i++) {
                 this.parens[i] = parens[i];
             }
         } else {
             this.parens = null;
         }
     }

     public void runTest()
     {
         test.say(tag + "(" + number + "): " + pattern);
         if (testCreation()) {
             testMatch();
         }
     }

     boolean testCreation()
     {
         try
         {
             // Compile it
             regexp = new RE();
             regexp.setProgram(test.compiler.compile(pattern));
             // Expression didn't cause an expected error
             if (badPattern)
             {
                 test.fail(log, "Was expected to be an error, but wasn't.");
                 return false;
             }

             return true;
         }
         // Some expressions *should* cause exceptions to be thrown
         catch (Exception e)
         {
             // If it was supposed to be an error, report success and continue
             if (badPattern)
             {
                 log.append("   Match: ERR\n");
                 success("Produces an error (" + e.toString() + "), as expected.");
                 return false;
             }

             // Wasn't supposed to be an error
             String message = (e.getMessage() == null) ? e.toString() : e.getMessage();
             test.fail(log, "Produces an unexpected exception \"" + message + "\"");
             e.printStackTrace();
         }
         catch (Error e)
         {
             // Internal error happened
             test.fail(log, "Compiler threw fatal error \"" + e.getMessage() + "\"");
             e.printStackTrace();
         }

         return false;
     }

     private void testMatch()
     {
         log.append("   Match against: '" + toMatch + "'\n");
         // Try regular matching
         try
         {
             // Match against the string
             boolean result = regexp.match(toMatch);
             log.append("   Matched: " + (result ? "YES" : "NO") + "\n");

             // Check result, parens, and iterators
             if (checkResult(result) && (!shouldMatch || checkParens()))
             {
                 // test match(CharacterIterator, int)
                 // for every CharacterIterator implementation.
                 log.append("   Match using StringCharacterIterator\n");
                 if (!tryMatchUsingCI(new StringCharacterIterator(toMatch)))
                     return;

                 log.append("   Match using CharacterArrayCharacterIterator\n");
                 if (!tryMatchUsingCI(new CharacterArrayCharacterIterator(toMatch.toCharArray(), 0, toMatch.length())))
                     return;

                 log.append("   Match using StreamCharacterIterator\n");
                 if (!tryMatchUsingCI(new StreamCharacterIterator(new StringBufferInputStream(toMatch))))
                     return;

                 log.append("   Match using ReaderCharacterIterator\n");
                 if (!tryMatchUsingCI(new ReaderCharacterIterator(new StringReader(toMatch))))
                     return;
             }
         }
         // Matcher blew it
         catch(Exception e)
         {
             test.fail(log, "Matcher threw exception: " + e.toString());
             e.printStackTrace();
         }
         // Internal error
         catch(Error e)
         {
             test.fail(log, "Matcher threw fatal error \"" + e.getMessage() + "\"");
             e.printStackTrace();
         }
     }

     private boolean checkResult(boolean result)
     {
         // Write status
         if (result == shouldMatch) {
             success((shouldMatch ? "Matched" : "Did not match")
                     + " \"" + toMatch + "\", as expected:");
             return true;
         } else {
             if (shouldMatch) {
                 test.fail(log, "Did not match \"" + toMatch + "\", when expected to.");
             } else {
                 test.fail(log, "Matched \"" + toMatch + "\", when not expected to.");
             }
             return false;
         }
     }

     private boolean checkParens()
     {
         // Show subexpression registers
         if (RETest.showSuccesses)
         {
             test.showParens(regexp);
         }

         log.append("   Paren count: " + regexp.getParenCount() + "\n");
         if (!assertEquals(log, "Wrong number of parens", parens.length, regexp.getParenCount()))
         {
             return false;
         }

         // Check registers against expected contents
         for (int p = 0; p < regexp.getParenCount(); p++)
         {
             log.append("   Paren " + p + ": " + regexp.getParen(p) + "\n");

             // Compare expected result with actual
             if ("null".equals(parens[p]) && regexp.getParen(p) == null)
             {
                 // Consider "null" in test file equal to null
                 continue;
             }
             if (!assertEquals(log, "Wrong register " + p, parens[p], regexp.getParen(p)))
             {
                 return false;
             }
         }

         return true;
     }

     boolean tryMatchUsingCI(CharacterIterator matchAgainst)
     {
         try {
             boolean result = regexp.match(matchAgainst, 0);
             log.append("   Match: " + (result ? "YES" : "NO") + "\n");
             return checkResult(result) && (!shouldMatch || checkParens());
         }
         // Matcher blew it
         catch(Exception e)
         {
             test.fail(log, "Matcher threw exception: " + e.toString());
             e.printStackTrace();
         }
         // Internal error
         catch(Error e)
         {
             test.fail(log, "Matcher threw fatal error \"" + e.getMessage() + "\"");
             e.printStackTrace();
         }
         return false;
     }

     public boolean assertEquals(StringBuffer log, String message, String expected, String actual)
     {
         if (expected != null && !expected.equals(actual)
             || actual != null && !actual.equals(expected))
         {
             test.fail(log, message + " (expected \"" + expected
                       + "\", actual \"" + actual + "\")");
             return false;
         }
         return true;
     }

     public boolean assertEquals(StringBuffer log, String message, int expected, int actual)
     {
         if (expected != actual) {
             test.fail(log, message + " (expected \"" + expected
                       + "\", actual \"" + actual + "\")");
             return false;
         }
         return true;
     }

     /**
      * Show a success
      * @param s Success story
      */
     void success(String s)
     {
         if (RETest.showSuccesses)
         {
             test.say("" + RETest.NEW_LINE + "-----------------------" + RETest.NEW_LINE + "");
             test.say("Expression #" + (number) + " \"" + pattern + "\" ");
             test.say("Success: " + s);
         }
     }
 }
	/*
	* reserved comment block
	* DO NOT REMOVE OR ALTER!
	*/
	/*
	* Copyright 1999-2004 The Apache Software Foundation.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.sun.org.apache.regexp.internal;

	import java.io.BufferedReader;
	import java.io.FileReader;
	import java.io.InputStreamReader;
	import java.io.PrintWriter;
	import java.io.File;
	import java.io.ByteArrayOutputStream;
	import java.io.ObjectOutputStream;
	import java.io.ByteArrayInputStream;
	import java.io.ObjectInputStream;
	import java.io.StringBufferInputStream;
	import java.io.StringReader;
	import java.io.IOException;

	/**
	* Data driven (and optionally interactive) testing harness to exercise regular
	* expression compiler and matching engine.
	*
	* @author <a href="mailto:jonl@muppetlabs.com">Jonathan Locke</a>
	* @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
	* @author <a href="mailto:gholam@xtra.co.nz">Michael McCallum</a>
	*/
	public class RETest
	{
	// True if we want to see output from success cases
	static final boolean showSuccesses = false;

	// A new line character.
	static final String NEW_LINE = System.getProperty( "line.separator" );

	// Construct a debug compiler
	REDebugCompiler compiler = new REDebugCompiler();

	/**
	* Main program entrypoint. If an argument is given, it will be compiled
	* and interactive matching will ensue. If no argument is given, the
	* file RETest.txt will be used as automated testing input.
	* @param args Command line arguments (optional regular expression)
	*/
	public static void main(String[] args)
	{
	try
	{
	if (!test( args )) {
	System.exit(1);
	}
	}
	catch (Exception e)
	{
	e.printStackTrace();
	System.exit(1);
	}
	}

	/**
	* Testing entrypoint.
	* @param args Command line arguments
	* @exception Exception thrown in case of error
	*/
	public static boolean test( String[] args ) throws Exception
	{
	RETest test = new RETest();
	// Run interactive tests against a single regexp
	if (args.length == 2)
	{
	test.runInteractiveTests(args[1]);
	}
	else if (args.length == 1)
	{
	// Run automated tests
	test.runAutomatedTests(args[0]);
	}
	else
	{
	System.out.println( "Usage: RETest ([-i] [regex]) ([/path/to/testfile.txt])" );
	System.out.println( "By Default will run automated tests from file 'docs/RETest.txt' ..." );
	System.out.println();
	test.runAutomatedTests("docs/RETest.txt");
	}
	return test.failures == 0;
	}

	/**
	* Constructor
	*/
	public RETest()
	{
	}

	/**
	* Compile and test matching against a single expression
	* @param expr Expression to compile and test
	*/
	void runInteractiveTests(String expr)
	{
	RE r = new RE();
	try
	{
	// Compile expression
	r.setProgram(compiler.compile(expr));

	// Show expression
	say("" + NEW_LINE + "" + expr + "" + NEW_LINE + "");

	// Show program for compiled expression
	PrintWriter writer = new PrintWriter( System.out );
	compiler.dumpProgram( writer );
	writer.flush();

	boolean running = true;
	// Test matching against compiled expression
	while ( running )
	{
	// Read from keyboard
	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	System.out.print("> ");
	System.out.flush();
	String match = br.readLine();

	if ( match != null )
	{
	// Try a match against the keyboard input
	if (r.match(match))
	{
	say("Match successful.");
	}
	else
	{
	say("Match failed.");
	}

	// Show subparen registers
	showParens(r);
	}
	else
	{
	running = false;
	System.out.println();
	}
	}
	}
	catch (Exception e)
	{
	say("Error: " + e.toString());
	e.printStackTrace();
	}
	}

	/**
	* Exit with a fatal error.
	* @param s Last famous words before exiting
	*/
	void die(String s)
	{
	say("FATAL ERROR: " + s);
	System.exit(-1);
	}

	/**
	* Fail with an error. Will print a big failure message to System.out.
	*
	* @param log Output before failure
	* @param s Failure description
	*/
	void fail(StringBuffer log, String s)
	{
	System.out.print(log.toString());
	fail(s);
	}

	/**
	* Fail with an error. Will print a big failure message to System.out.
	*
	* @param s Failure description
	*/
	void fail(String s)
	{
	failures++;
	say("" + NEW_LINE + "");
	say("*******************************************************");
	say("******************* FAILURE! ********************");
	say("*******************************************************");
	say("" + NEW_LINE + "");
	say(s);
	say("");
	// make sure the writer gets flushed.
	if (compiler != null) {
	PrintWriter writer = new PrintWriter( System.out );
	compiler.dumpProgram( writer );
	writer.flush();
	say("" + NEW_LINE + "");
	}
	}

	/**
	* Say something to standard out
	* @param s What to say
	*/
	void say(String s)
	{
	System.out.println(s);
	}

	/**
	* Dump parenthesized subexpressions found by a regular expression matcher object
	* @param r Matcher object with results to show
	*/
	void showParens(RE r)
	{
	// Loop through each paren
	for (int i = 0; i < r.getParenCount(); i++)
	{
	// Show paren register
	say("$" + i + " = " + r.getParen(i));
	}
	}

	/*
	* number in automated test
	*/
	int testCount = 0;

	/*
	* Count of failures in automated test
	*/
	int failures = 0;

	/**
	* Run automated tests in RETest.txt file (from Perl 4.0 test battery)
	* @exception Exception thrown in case of error
	*/
	void runAutomatedTests(String testDocument) throws Exception
	{
	long ms = System.currentTimeMillis();

	// Some unit tests
	testPrecompiledRE();
	testSplitAndGrep();
	testSubst();
	testOther();

	// Test from script file
	File testInput = new File(testDocument);
	if (! testInput.exists()) {
	throw new Exception ("Could not find: " + testDocument);
	}

	BufferedReader br = new BufferedReader(new FileReader(testInput));
	try
	{
	// While input is available, parse lines
	while (br.ready())
	{
	RETestCase testcase = getNextTestCase(br);
	if (testcase != null) {
	testcase.runTest();
	}
	}
	}
	finally
	{
	br.close();
	}

	// Show match time
	say(NEW_LINE + NEW_LINE + "Match time = " + (System.currentTimeMillis() - ms) + " ms.");

	// Print final results
	if (failures > 0) {
	say("************* THERE ARE FAILURES! *****************");
	}
	say("Tests complete. " + testCount + " tests, " + failures + " failure(s).");
	}

	/**
	* Run automated unit test
	* @exception Exception thrown in case of error
	*/
	void testOther() throws Exception
	{
	// Serialization test 1: Compile regexp and serialize/deserialize it
	RE r = new RE("(a*)b");
	say("Serialized/deserialized (a*)b");
	ByteArrayOutputStream out = new ByteArrayOutputStream(128);
	new ObjectOutputStream(out).writeObject(r);
	ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
	r = (RE)new ObjectInputStream(in).readObject();
	if (!r.match("aaab"))
	{
	fail("Did not match 'aaab' with deserialized RE.");
	} else {
	say("aaaab = true");
	showParens(r);
	}

	// Serialization test 2: serialize/deserialize used regexp
	out.reset();
	say("Deserialized (a*)b");
	new ObjectOutputStream(out).writeObject(r);
	in = new ByteArrayInputStream(out.toByteArray());
	r = (RE)new ObjectInputStream(in).readObject();
	if (r.getParenCount() != 0)
	{
	fail("Has parens after deserialization.");
	}
	if (!r.match("aaab"))
	{
	fail("Did not match 'aaab' with deserialized RE.");
	} else {
	say("aaaab = true");
	showParens(r);
	}

	// Test MATCH_CASEINDEPENDENT
	r = new RE("abc(\\w*)");
	say("MATCH_CASEINDEPENDENT abc(\\w*)");
	r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
	say("abc(d*)");
	if (!r.match("abcddd"))
	{
	fail("Did not match 'abcddd'.");
	} else {
	say("abcddd = true");
	showParens(r);
	}

	if (!r.match("aBcDDdd"))
	{
	fail("Did not match 'aBcDDdd'.");
	} else {
	say("aBcDDdd = true");
	showParens(r);
	}

	if (!r.match("ABCDDDDD"))
	{
	fail("Did not match 'ABCDDDDD'.");
	} else {
	say("ABCDDDDD = true");
	showParens(r);
	}

	r = new RE("(A*)b\\1");
	r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
	if (!r.match("AaAaaaBAAAAAA"))
	{
	fail("Did not match 'AaAaaaBAAAAAA'.");
	} else {
	say("AaAaaaBAAAAAA = true");
	showParens(r);
	}

	r = new RE("[A-Z]*");
	r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
	if (!r.match("CaBgDe12"))
	{
	fail("Did not match 'CaBgDe12'.");
	} else {
	say("CaBgDe12 = true");
	showParens(r);
	}

	// Test MATCH_MULTILINE. Test for eol/bol symbols.
	r = new RE("^abc$", RE.MATCH_MULTILINE);
	if (!r.match("\nabc")) {
	fail("\"\\nabc\" doesn't match \"^abc$\"");
	}
	if (!r.match("\rabc")) {
	fail("\"\\rabc\" doesn't match \"^abc$\"");
	}
	if (!r.match("\r\nabc")) {
	fail("\"\\r\\nabc\" doesn't match \"^abc$\"");
	}
	if (!r.match("\u0085abc")) {
	fail("\"\\u0085abc\" doesn't match \"^abc$\"");
	}
	if (!r.match("\u2028abc")) {
	fail("\"\\u2028abc\" doesn't match \"^abc$\"");
	}
	if (!r.match("\u2029abc")) {
	fail("\"\\u2029abc\" doesn't match \"^abc$\"");
	}

	// Test MATCH_MULTILINE. Test that '.' does not matches new line.
	r = new RE("^a.*b$", RE.MATCH_MULTILINE);
	if (r.match("a\nb")) {
	fail("\"a\\nb\" matches \"^a.*b$\"");
	}
	if (r.match("a\rb")) {
	fail("\"a\\rb\" matches \"^a.*b$\"");
	}
	if (r.match("a\r\nb")) {
	fail("\"a\\r\\nb\" matches \"^a.*b$\"");
	}
	if (r.match("a\u0085b")) {
	fail("\"a\\u0085b\" matches \"^a.*b$\"");
	}
	if (r.match("a\u2028b")) {
	fail("\"a\\u2028b\" matches \"^a.*b$\"");
	}
	if (r.match("a\u2029b")) {
	fail("\"a\\u2029b\" matches \"^a.*b$\"");
	}
	}

	private void testPrecompiledRE()
	{
	// Pre-compiled regular expression "a*b"
	char[] re1Instructions =
	{
	0x007c, 0x0000, 0x001a, 0x007c, 0x0000, 0x000d, 0x0041,
	0x0001, 0x0004, 0x0061, 0x007c, 0x0000, 0x0003, 0x0047,
	0x0000, 0xfff6, 0x007c, 0x0000, 0x0003, 0x004e, 0x0000,
	0x0003, 0x0041, 0x0001, 0x0004, 0x0062, 0x0045, 0x0000,
	0x0000,
	};

	REProgram re1 = new REProgram(re1Instructions);

	// Simple test of pre-compiled regular expressions
	RE r = new RE(re1);
	say("a*b");
	boolean result = r.match("aaab");
	say("aaab = " + result);
	showParens(r);
	if (!result) {
	fail("\"aaab\" doesn't match to precompiled \"a*b\"");
	}

	result = r.match("b");
	say("b = " + result);
	showParens(r);
	if (!result) {
	fail("\"b\" doesn't match to precompiled \"a*b\"");
	}

	result = r.match("c");
	say("c = " + result);
	showParens(r);
	if (result) {
	fail("\"c\" matches to precompiled \"a*b\"");
	}

	result = r.match("ccccaaaaab");
	say("ccccaaaaab = " + result);
	showParens(r);
	if (!result) {
	fail("\"ccccaaaaab\" doesn't match to precompiled \"a*b\"");
	}
	}

	private void testSplitAndGrep()
	{
	String[] expected = {"xxxx", "xxxx", "yyyy", "zzz"};
	RE r = new RE("a*b");
	String[] s = r.split("xxxxaabxxxxbyyyyaaabzzz");
	for (int i = 0; i < expected.length && i < s.length; i++) {
	assertEquals("Wrong splitted part", expected[i], s[i]);
	}
	assertEquals("Wrong number of splitted parts", expected.length,
	s.length);

	r = new RE("x+");
	expected = new String[] {"xxxx", "xxxx"};
	s = r.grep(s);
	for (int i = 0; i < s.length; i++)
	{
	say("s[" + i + "] = " + s[i]);
	assertEquals("Grep fails", expected[i], s[i]);
	}
	assertEquals("Wrong number of string found by grep", expected.length,
	s.length);
	}

	private void testSubst()
	{
	RE r = new RE("a*b");
	String expected = "-foo-garply-wacky-";
	String actual = r.subst("aaaabfooaaabgarplyaaabwackyb", "-");
	assertEquals("Wrong result of substitution in \"a*b\"", expected, actual);

	// Test subst() with backreferences
	r = new RE("http://[\\.\\w\\-\\?/~_@&=%]+");
	actual = r.subst("visit us: http://www.apache.org!",
	"1234<a href=\"$0\">$0</a>", RE.REPLACE_BACKREFERENCES);
	assertEquals("Wrong subst() result", "visit us: 1234<a href=\"http://www.apache.org\">http://www.apache.org</a>!", actual);

	// Test subst() with backreferences without leading characters
	// before first backreference
	r = new RE("(.?)=(.)");
	actual = r.subst("variable=value",
	"$1_test_$212", RE.REPLACE_BACKREFERENCES);
	assertEquals("Wrong subst() result", "variable_test_value12", actual);

	// Test subst() with NO backreferences
	r = new RE("^a$");
	actual = r.subst("a",
	"b", RE.REPLACE_BACKREFERENCES);
	assertEquals("Wrong subst() result", "b", actual);

	// Test subst() with NO backreferences
	r = new RE("^a$", RE.MATCH_MULTILINE);
	actual = r.subst("\r\na\r\n",
	"b", RE.REPLACE_BACKREFERENCES);
	assertEquals("Wrong subst() result", "\r\nb\r\n", actual);
	}

	public void assertEquals(String message, String expected, String actual)
	{
	if (expected != null && !expected.equals(actual)
	\|\| actual != null && !actual.equals(expected))
	{
	fail(message + " (expected \"" + expected
	+ "\", actual \"" + actual + "\")");
	}
	}

	public void assertEquals(String message, int expected, int actual)
	{
	if (expected != actual) {
	fail(message + " (expected \"" + expected
	+ "\", actual \"" + actual + "\")");
	}
	}

	/**
	* Converts yesno string to boolean.
	* @param yesno string representation of expected result
	* @return true if yesno is "YES", false if yesno is "NO"
	* stops program otherwise.
	*/
	private boolean getExpectedResult(String yesno)
	{
	if ("NO".equals(yesno))
	{
	return false;
	}
	else if ("YES".equals(yesno))
	{
	return true;
	}
	else
	{
	// Bad test script
	die("Test script error!");
	return false; //to please javac
	}
	}

	/**
	* Finds next test description in a given script.
	* @param br <code>BufferedReader</code> for a script file
	* @return strign tag for next test description
	* @exception IOException if some io problems occured
	*/
	private String findNextTest(BufferedReader br) throws IOException
	{
	String number = "";

	while (br.ready())
	{
	number = br.readLine();
	if (number == null)
	{
	break;
	}
	number = number.trim();
	if (number.startsWith("#"))
	{
	break;
	}
	if (!number.equals(""))
	{
	say("Script error. Line = " + number);
	System.exit(-1);
	}
	}
	return number;
	}

	/**
	* Creates testcase for the next test description in the script file.
	* @param br <code>BufferedReader</code> for script file.
	* @return a new tescase or null.
	* @exception IOException if some io problems occured
	*/
	private RETestCase getNextTestCase(BufferedReader br) throws IOException
	{
	// Find next re test case
	final String tag = findNextTest(br);

	// Are we done?
	if (!br.ready())
	{
	return null;
	}

	// Get expression
	final String expr = br.readLine();

	// Get test information
	final String matchAgainst = br.readLine();
	final boolean badPattern = "ERR".equals(matchAgainst);
	boolean shouldMatch = false;
	int expectedParenCount = 0;
	String[] expectedParens = null;

	if (!badPattern) {
	shouldMatch = getExpectedResult(br.readLine().trim());
	if (shouldMatch) {
	expectedParenCount = Integer.parseInt(br.readLine().trim());
	expectedParens = new String[expectedParenCount];
	for (int i = 0; i < expectedParenCount; i++) {
	expectedParens[i] = br.readLine();
	}
	}
	}

	return new RETestCase(this, tag, expr, matchAgainst, badPattern,
	shouldMatch, expectedParens);
	}
	}

	final class RETestCase
	{
	final private StringBuffer log = new StringBuffer();
	final private int number;
	final private String tag; // number from script file
	final private String pattern;
	final private String toMatch;
	final private boolean badPattern;
	final private boolean shouldMatch;
	final private String[] parens;
	final private RETest test;
	private RE regexp;

	public RETestCase(RETest test, String tag, String pattern,
	String toMatch, boolean badPattern,
	boolean shouldMatch, String[] parens)
	{
	this.number = ++test.testCount;
	this.test = test;
	this.tag = tag;
	this.pattern = pattern;
	this.toMatch = toMatch;
	this.badPattern = badPattern;
	this.shouldMatch = shouldMatch;
	if (parens != null) {
	this.parens = new String[parens.length];
	for (int i = 0; i < parens.length; i++) {
	this.parens[i] = parens[i];
	}
	} else {
	this.parens = null;
	}
	}

	public void runTest()
	{
	test.say(tag + "(" + number + "): " + pattern);
	if (testCreation()) {
	testMatch();
	}
	}

	boolean testCreation()
	{
	try
	{
	// Compile it
	regexp = new RE();
	regexp.setProgram(test.compiler.compile(pattern));
	// Expression didn't cause an expected error
	if (badPattern)
	{
	test.fail(log, "Was expected to be an error, but wasn't.");
	return false;
	}

	return true;
	}
	// Some expressions should cause exceptions to be thrown
	catch (Exception e)
	{
	// If it was supposed to be an error, report success and continue
	if (badPattern)
	{
	log.append(" Match: ERR\n");
	success("Produces an error (" + e.toString() + "), as expected.");
	return false;
	}

	// Wasn't supposed to be an error
	String message = (e.getMessage() == null) ? e.toString() : e.getMessage();
	test.fail(log, "Produces an unexpected exception \"" + message + "\"");
	e.printStackTrace();
	}
	catch (Error e)
	{
	// Internal error happened
	test.fail(log, "Compiler threw fatal error \"" + e.getMessage() + "\"");
	e.printStackTrace();
	}

	return false;
	}

	private void testMatch()
	{
	log.append(" Match against: '" + toMatch + "'\n");
	// Try regular matching
	try
	{
	// Match against the string
	boolean result = regexp.match(toMatch);
	log.append(" Matched: " + (result ? "YES" : "NO") + "\n");

	// Check result, parens, and iterators
	if (checkResult(result) && (!shouldMatch \|\| checkParens()))
	{
	// test match(CharacterIterator, int)
	// for every CharacterIterator implementation.
	log.append(" Match using StringCharacterIterator\n");
	if (!tryMatchUsingCI(new StringCharacterIterator(toMatch)))
	return;

	log.append(" Match using CharacterArrayCharacterIterator\n");
	if (!tryMatchUsingCI(new CharacterArrayCharacterIterator(toMatch.toCharArray(), 0, toMatch.length())))
	return;

	log.append(" Match using StreamCharacterIterator\n");
	if (!tryMatchUsingCI(new StreamCharacterIterator(new StringBufferInputStream(toMatch))))
	return;

	log.append(" Match using ReaderCharacterIterator\n");
	if (!tryMatchUsingCI(new ReaderCharacterIterator(new StringReader(toMatch))))
	return;
	}
	}
	// Matcher blew it
	catch(Exception e)
	{
	test.fail(log, "Matcher threw exception: " + e.toString());
	e.printStackTrace();
	}
	// Internal error
	catch(Error e)
	{
	test.fail(log, "Matcher threw fatal error \"" + e.getMessage() + "\"");
	e.printStackTrace();
	}
	}

	private boolean checkResult(boolean result)
	{
	// Write status
	if (result == shouldMatch) {
	success((shouldMatch ? "Matched" : "Did not match")
	+ " \"" + toMatch + "\", as expected:");
	return true;
	} else {
	if (shouldMatch) {
	test.fail(log, "Did not match \"" + toMatch + "\", when expected to.");
	} else {
	test.fail(log, "Matched \"" + toMatch + "\", when not expected to.");
	}
	return false;
	}
	}

	private boolean checkParens()
	{
	// Show subexpression registers
	if (RETest.showSuccesses)
	{
	test.showParens(regexp);
	}

	log.append(" Paren count: " + regexp.getParenCount() + "\n");
	if (!assertEquals(log, "Wrong number of parens", parens.length, regexp.getParenCount()))
	{
	return false;
	}

	// Check registers against expected contents
	for (int p = 0; p < regexp.getParenCount(); p++)
	{
	log.append(" Paren " + p + ": " + regexp.getParen(p) + "\n");

	// Compare expected result with actual
	if ("null".equals(parens[p]) && regexp.getParen(p) == null)
	{
	// Consider "null" in test file equal to null
	continue;
	}
	if (!assertEquals(log, "Wrong register " + p, parens[p], regexp.getParen(p)))
	{
	return false;
	}
	}

	return true;
	}

	boolean tryMatchUsingCI(CharacterIterator matchAgainst)
	{
	try {
	boolean result = regexp.match(matchAgainst, 0);
	log.append(" Match: " + (result ? "YES" : "NO") + "\n");
	return checkResult(result) && (!shouldMatch \|\| checkParens());
	}
	// Matcher blew it
	catch(Exception e)
	{
	test.fail(log, "Matcher threw exception: " + e.toString());
	e.printStackTrace();
	}
	// Internal error
	catch(Error e)
	{
	test.fail(log, "Matcher threw fatal error \"" + e.getMessage() + "\"");
	e.printStackTrace();
	}
	return false;
	}

	public boolean assertEquals(StringBuffer log, String message, String expected, String actual)
	{
	if (expected != null && !expected.equals(actual)
	\|\| actual != null && !actual.equals(expected))
	{
	test.fail(log, message + " (expected \"" + expected
	+ "\", actual \"" + actual + "\")");
	return false;
	}
	return true;
	}

	public boolean assertEquals(StringBuffer log, String message, int expected, int actual)
	{
	if (expected != actual) {
	test.fail(log, message + " (expected \"" + expected
	+ "\", actual \"" + actual + "\")");
	return false;
	}
	return true;
	}

	/**
	* Show a success
	* @param s Success story
	*/
	void success(String s)
	{
	if (RETest.showSuccesses)
	{
	test.say("" + RETest.NEW_LINE + "-----------------------" + RETest.NEW_LINE + "");
	test.say("Expression #" + (number) + " \"" + pattern + "\" ");
	test.say("Success: " + s);
	}
	}
	}