| Methods Summary |
|---|
| public static void | _main(java.lang.String[] arg)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.
try
{
//new RETest(arg);
test();
}
catch (Exception e)
{
e.printStackTrace();
}
|
| void | die(java.lang.String s)Exit with a fatal error.
say("FATAL ERROR: " + s);
System.exit(0);
|
| void | fail(java.lang.String s)Fail with an error
failures++;
say("\n");
say("*******************************************************");
say("********************* FAILURE! **********************");
say("*******************************************************");
say("\n");
say(s);
say("");
compiler.dumpProgram(new PrintWriter(System.out));
say("\n");
|
| void | runAutomatedTests(java.lang.String testDocument)Run automated tests in RETest.txt file (from Perl 4.0 test battery)
long ms = System.currentTimeMillis();
// Simple test of pre-compiled regular expressions
RE r = new RE(re1);
say("a*b");
say("aaaab = " + r.match("aaab"));
showParens(r);
say("b = " + r.match("b"));
showParens(r);
say("c = " + r.match("c"));
showParens(r);
say("ccccaaaaab = " + r.match("ccccaaaaab"));
showParens(r);
r = new RE("a*b");
String[] s = r.split("xxxxaabxxxxbyyyyaaabzzz");
r = new RE("x+");
s = r.grep(s);
for (int i = 0; i < s.length; i++)
{
System.out.println ("s[" + i + "] = " + s[i]);
}
r = new RE("a*b");
String s1 = r.subst("aaaabfooaaabgarplyaaabwackyb", "-");
System.out.println ("s = " + s1);
// 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())
{
// Find next re test case
String number = "";
String yesno;
while (br.ready())
{
number = br.readLine();
if (number == null)
{
break;
}
number = number.trim();
if (number.startsWith("#"))
{
break;
}
if (!number.equals(""))
{
System.out.println ("Script error. Line = " + number);
System.exit(0);
}
}
// Are we done?
if (!br.ready())
{
break;
}
// Get expression
expr = br.readLine();
n++;
say("");
say(n + ". " + expr);
say("");
// Compile it
try
{
r.setProgram(compiler.compile(expr));
}
// Some expressions *should* cause exceptions to be thrown
catch (Exception e)
{
// Get expected result
yesno = br.readLine().trim();
// If it was supposed to be an error, report success and continue
if (yesno.equals("ERR"))
{
say(" Match: ERR");
success("Produces an error (" + e.toString() + "), as expected.");
continue;
}
// Wasn't supposed to be an error
fail("Produces the unexpected error \"" + e.getMessage() + "\"");
}
catch (Error e)
{
// Internal error happened
fail("Compiler threw fatal error \"" + e.getMessage() + "\"");
e.printStackTrace();
}
// Get string to match against
String matchAgainst = br.readLine().trim();
say(" Match against: '" + matchAgainst + "'");
// Expression didn't cause an expected error
if (matchAgainst.equals("ERR"))
{
fail("Was expected to be an error, but wasn't.");
continue;
}
// Try matching
try
{
// Match against the string
boolean b = r.match(matchAgainst);
// Get expected result
yesno = br.readLine().trim();
// If match succeeded
if (b)
{
// Status
say(" Match: YES");
// Match wasn't supposed to succeed
if (yesno.equals("NO"))
{
fail("Matched \"" + matchAgainst + "\", when not expected to.");
}
else
if (yesno.equals("YES"))
{
// Match succeeded as expected
success("Matched \"" + matchAgainst + "\", as expected:");
// Show subexpression registers
if (showSuccesses)
{
showParens(r);
}
say(" Paren count: " + r.getParenCount());
// Check registers against expected contents
for (int p = 0; p < r.getParenCount(); p++)
{
// Get next register
String register = br.readLine().trim();
say(" Paren " + p + " : " + r.getParen(p));
// Compare expected result with actual
if (!register.equals(r.getParen(p)))
{
// Register isn't what it was supposed to be
fail("Register " + p + " should be = \"" + register + "\", but is \"" + r.getParen(p) + "\" instead.");
}
}
}
else
{
// Bad test script
die("Test script error!");
}
}
else
{
// Status
say(" Match: NO");
// Match failed
if (yesno.equals("YES"))
{
// Should have failed
fail("Did not match \"" + matchAgainst + "\", when expected to.");
}
else
if (yesno.equals("NO"))
{
// Should have failed
success("Did not match \"" + matchAgainst + "\", as expected.");
}
else
{
// Bad test script
die("Test script error!");
}
}
}
// Matcher blew it
catch (Exception e)
{
fail("Matcher threw exception: " + e.toString());
e.printStackTrace();
}
// Internal error
catch (Error e)
{
fail("Matcher threw fatal error \"" + e.getMessage() + "\"");
e.printStackTrace();
}
}
}
finally
{
br.close();
}
// Show match time
System.out.println ("\n\nMatch time = " + (System.currentTimeMillis() - ms) + " ms.");
// Print final results
System.out.println ("\nTests complete. " + n + " tests, " + failures + " failure(s).");
|
| void | runInteractiveTests(java.lang.String expr)Compile and test matching against a single expression
try
{
// Compile expression
r.setProgram(compiler.compile(expr));
// Show expression
say("\n" + expr + "\n");
// Show program for compiled expression
compiler.dumpProgram(new PrintWriter(System.out));
// Test matching against compiled expression
while (true)
{
// Read from keyboard
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.print("> ");
System.out.flush();
String match = br.readLine();
// Try a match against the keyboard input
if (r.match(match))
{
say("Match successful.");
}
else
{
say("Match failed.");
}
// Show subparen registers
showParens(r);
}
}
catch (Exception e)
{
say("Error: " + e.toString());
e.printStackTrace();
}
|
| void | say(java.lang.String s)Say something to standard out
System.out.println (s);
|
| void | show()Show an expression
say("\n-----------------------\n");
say("Expression #" + (n) + " \"" + expr + "\" ");
|
| void | showParens(RE r)Dump parenthesized subexpressions found by a regular expression matcher object
// Loop through each paren
for (int i = 0; i < r.getParenCount(); i++)
{
// Show paren register
say("$" + i + " = " + r.getParen(i));
}
|
| void | success(java.lang.String s)Show a success
if (showSuccesses)
{
show();
say("Success: " + s);
}
|
| public static boolean | test()Testing entrypoint.
RETest test = new RETest();
test.runAutomatedTests("docs/RETest.txt");
return test.failures == 0;
|
