1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 /*
6 * Copyright 1999-2004 The Apache Software Foundation.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21 package com.sun.org.apache.regexp.internal;
22
23 import java.io.BufferedReader;
24 import java.io.FileReader;
25 import java.io.InputStreamReader;
26 import java.io.PrintWriter;
27 import java.io.File;
28 import java.io.ByteArrayOutputStream;
29 import java.io.ObjectOutputStream;
30 import java.io.ByteArrayInputStream;
31 import java.io.ObjectInputStream;
32 import java.io.StringBufferInputStream;
33 import java.io.StringReader;
34 import java.io.IOException;
35
36 /**
37 * Data driven (and optionally interactive) testing harness to exercise regular
38 * expression compiler and matching engine.
39 *
40 * @author <a href="mailto:jonl@muppetlabs.com">Jonathan Locke</a>
41 * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
42 * @author <a href="mailto:gholam@xtra.co.nz">Michael McCallum</a>
43 */
44 public class RETest
45 {
46 // True if we want to see output from success cases
47 static final boolean showSuccesses = false;
48
49 // A new line character.
50 static final String NEW_LINE = System.getProperty( "line.separator" );
51
52 // Construct a debug compiler
53 REDebugCompiler compiler = new REDebugCompiler();
54
55 /**
56 * Main program entrypoint. If an argument is given, it will be compiled
57 * and interactive matching will ensue. If no argument is given, the
58 * file RETest.txt will be used as automated testing input.
59 * @param args Command line arguments (optional regular expression)
60 */
61 public static void main(String[] args)
62 {
63 try
64 {
65 if (!test( args )) {
66 System.exit(1);
67 }
68 }
69 catch (Exception e)
70 {
71 e.printStackTrace();
72 System.exit(1);
73 }
74 }
75
76 /**
77 * Testing entrypoint.
78 * @param args Command line arguments
79 * @exception Exception thrown in case of error
80 */
81 public static boolean test( String[] args ) throws Exception
82 {
83 RETest test = new RETest();
84 // Run interactive tests against a single regexp
85 if (args.length == 2)
86 {
87 test.runInteractiveTests(args[1]);
88 }
89 else if (args.length == 1)
90 {
91 // Run automated tests
92 test.runAutomatedTests(args[0]);
93 }
94 else
95 {
96 System.out.println( "Usage: RETest ([-i] [regex]) ([/path/to/testfile.txt])" );
97 System.out.println( "By Default will run automated tests from file 'docs/RETest.txt' ..." );
98 System.out.println();
99 test.runAutomatedTests("docs/RETest.txt");
100 }
101 return test.failures == 0;
102 }
103
104 /**
105 * Constructor
106 */
107 public RETest()
108 {
109 }
110
111 /**
112 * Compile and test matching against a single expression
113 * @param expr Expression to compile and test
114 */
115 void runInteractiveTests(String expr)
116 {
117 RE r = new RE();
118 try
119 {
120 // Compile expression
121 r.setProgram(compiler.compile(expr));
122
123 // Show expression
124 say("" + NEW_LINE + "" + expr + "" + NEW_LINE + "");
125
126 // Show program for compiled expression
127 PrintWriter writer = new PrintWriter( System.out );
128 compiler.dumpProgram( writer );
129 writer.flush();
130
131 boolean running = true;
132 // Test matching against compiled expression
133 while ( running )
134 {
135 // Read from keyboard
136 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
137 System.out.print("> ");
138 System.out.flush();
139 String match = br.readLine();
140
141 if ( match != null )
142 {
143 // Try a match against the keyboard input
144 if (r.match(match))
145 {
146 say("Match successful.");
147 }
148 else
149 {
150 say("Match failed.");
151 }
152
153 // Show subparen registers
154 showParens(r);
155 }
156 else
157 {
158 running = false;
159 System.out.println();
160 }
161 }
162 }
163 catch (Exception e)
164 {
165 say("Error: " + e.toString());
166 e.printStackTrace();
167 }
168 }
169
170 /**
171 * Exit with a fatal error.
172 * @param s Last famous words before exiting
173 */
174 void die(String s)
175 {
176 say("FATAL ERROR: " + s);
177 System.exit(-1);
178 }
179
180 /**
181 * Fail with an error. Will print a big failure message to System.out.
182 *
183 * @param log Output before failure
184 * @param s Failure description
185 */
186 void fail(StringBuffer log, String s)
187 {
188 System.out.print(log.toString());
189 fail(s);
190 }
191
192 /**
193 * Fail with an error. Will print a big failure message to System.out.
194 *
195 * @param s Failure description
196 */
197 void fail(String s)
198 {
199 failures++;
200 say("" + NEW_LINE + "");
201 say("*******************************************************");
202 say("********************* FAILURE! **********************");
203 say("*******************************************************");
204 say("" + NEW_LINE + "");
205 say(s);
206 say("");
207 // make sure the writer gets flushed.
208 if (compiler != null) {
209 PrintWriter writer = new PrintWriter( System.out );
210 compiler.dumpProgram( writer );
211 writer.flush();
212 say("" + NEW_LINE + "");
213 }
214 }
215
216 /**
217 * Say something to standard out
218 * @param s What to say
219 */
220 void say(String s)
221 {
222 System.out.println(s);
223 }
224
225 /**
226 * Dump parenthesized subexpressions found by a regular expression matcher object
227 * @param r Matcher object with results to show
228 */
229 void showParens(RE r)
230 {
231 // Loop through each paren
232 for (int i = 0; i < r.getParenCount(); i++)
233 {
234 // Show paren register
235 say("$" + i + " = " + r.getParen(i));
236 }
237 }
238
239 /*
240 * number in automated test
241 */
242 int testCount = 0;
243
244 /*
245 * Count of failures in automated test
246 */
247 int failures = 0;
248
249 /**
250 * Run automated tests in RETest.txt file (from Perl 4.0 test battery)
251 * @exception Exception thrown in case of error
252 */
253 void runAutomatedTests(String testDocument) throws Exception
254 {
255 long ms = System.currentTimeMillis();
256
257 // Some unit tests
258 testPrecompiledRE();
259 testSplitAndGrep();
260 testSubst();
261 testOther();
262
263 // Test from script file
264 File testInput = new File(testDocument);
265 if (! testInput.exists()) {
266 throw new Exception ("Could not find: " + testDocument);
267 }
268
269 BufferedReader br = new BufferedReader(new FileReader(testInput));
270 try
271 {
272 // While input is available, parse lines
273 while (br.ready())
274 {
275 RETestCase testcase = getNextTestCase(br);
276 if (testcase != null) {
277 testcase.runTest();
278 }
279 }
280 }
281 finally
282 {
283 br.close();
284 }
285
286 // Show match time
287 say(NEW_LINE + NEW_LINE + "Match time = " + (System.currentTimeMillis() - ms) + " ms.");
288
289 // Print final results
290 if (failures > 0) {
291 say("*************** THERE ARE FAILURES! *******************");
292 }
293 say("Tests complete. " + testCount + " tests, " + failures + " failure(s).");
294 }
295
296 /**
297 * Run automated unit test
298 * @exception Exception thrown in case of error
299 */
300 void testOther() throws Exception
301 {
302 // Serialization test 1: Compile regexp and serialize/deserialize it
303 RE r = new RE("(a*)b");
304 say("Serialized/deserialized (a*)b");
305 ByteArrayOutputStream out = new ByteArrayOutputStream(128);
306 new ObjectOutputStream(out).writeObject(r);
307 ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
308 r = (RE)new ObjectInputStream(in).readObject();
309 if (!r.match("aaab"))
310 {
311 fail("Did not match 'aaab' with deserialized RE.");
312 } else {
313 say("aaaab = true");
314 showParens(r);
315 }
316
317 // Serialization test 2: serialize/deserialize used regexp
318 out.reset();
319 say("Deserialized (a*)b");
320 new ObjectOutputStream(out).writeObject(r);
321 in = new ByteArrayInputStream(out.toByteArray());
322 r = (RE)new ObjectInputStream(in).readObject();
323 if (r.getParenCount() != 0)
324 {
325 fail("Has parens after deserialization.");
326 }
327 if (!r.match("aaab"))
328 {
329 fail("Did not match 'aaab' with deserialized RE.");
330 } else {
331 say("aaaab = true");
332 showParens(r);
333 }
334
335 // Test MATCH_CASEINDEPENDENT
336 r = new RE("abc(\\w*)");
337 say("MATCH_CASEINDEPENDENT abc(\\w*)");
338 r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
339 say("abc(d*)");
340 if (!r.match("abcddd"))
341 {
342 fail("Did not match 'abcddd'.");
343 } else {
344 say("abcddd = true");
345 showParens(r);
346 }
347
348 if (!r.match("aBcDDdd"))
349 {
350 fail("Did not match 'aBcDDdd'.");
351 } else {
352 say("aBcDDdd = true");
353 showParens(r);
354 }
355
356 if (!r.match("ABCDDDDD"))
357 {
358 fail("Did not match 'ABCDDDDD'.");
359 } else {
360 say("ABCDDDDD = true");
361 showParens(r);
362 }
363
364 r = new RE("(A*)b\\1");
365 r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
366 if (!r.match("AaAaaaBAAAAAA"))
367 {
368 fail("Did not match 'AaAaaaBAAAAAA'.");
369 } else {
370 say("AaAaaaBAAAAAA = true");
371 showParens(r);
372 }
373
374 r = new RE("[A-Z]*");
375 r.setMatchFlags(RE.MATCH_CASEINDEPENDENT);
376 if (!r.match("CaBgDe12"))
377 {
378 fail("Did not match 'CaBgDe12'.");
379 } else {
380 say("CaBgDe12 = true");
381 showParens(r);
382 }
383
384 // Test MATCH_MULTILINE. Test for eol/bol symbols.
385 r = new RE("^abc$", RE.MATCH_MULTILINE);
386 if (!r.match("\nabc")) {
387 fail("\"\\nabc\" doesn't match \"^abc$\"");
388 }
389 if (!r.match("\rabc")) {
390 fail("\"\\rabc\" doesn't match \"^abc$\"");
391 }
392 if (!r.match("\r\nabc")) {
393 fail("\"\\r\\nabc\" doesn't match \"^abc$\"");
394 }
395 if (!r.match("\u0085abc")) {
396 fail("\"\\u0085abc\" doesn't match \"^abc$\"");
397 }
398 if (!r.match("\u2028abc")) {
399 fail("\"\\u2028abc\" doesn't match \"^abc$\"");
400 }
401 if (!r.match("\u2029abc")) {
402 fail("\"\\u2029abc\" doesn't match \"^abc$\"");
403 }
404
405 // Test MATCH_MULTILINE. Test that '.' does not matches new line.
406 r = new RE("^a.*b$", RE.MATCH_MULTILINE);
407 if (r.match("a\nb")) {
408 fail("\"a\\nb\" matches \"^a.*b$\"");
409 }
410 if (r.match("a\rb")) {
411 fail("\"a\\rb\" matches \"^a.*b$\"");
412 }
413 if (r.match("a\r\nb")) {
414 fail("\"a\\r\\nb\" matches \"^a.*b$\"");
415 }
416 if (r.match("a\u0085b")) {
417 fail("\"a\\u0085b\" matches \"^a.*b$\"");
418 }
419 if (r.match("a\u2028b")) {
420 fail("\"a\\u2028b\" matches \"^a.*b$\"");
421 }
422 if (r.match("a\u2029b")) {
423 fail("\"a\\u2029b\" matches \"^a.*b$\"");
424 }
425 }
426
427 private void testPrecompiledRE()
428 {
429 // Pre-compiled regular expression "a*b"
430 char[] re1Instructions =
431 {
432 0x007c, 0x0000, 0x001a, 0x007c, 0x0000, 0x000d, 0x0041,
433 0x0001, 0x0004, 0x0061, 0x007c, 0x0000, 0x0003, 0x0047,
434 0x0000, 0xfff6, 0x007c, 0x0000, 0x0003, 0x004e, 0x0000,
435 0x0003, 0x0041, 0x0001, 0x0004, 0x0062, 0x0045, 0x0000,
436 0x0000,
437 };
438
439 REProgram re1 = new REProgram(re1Instructions);
440
441 // Simple test of pre-compiled regular expressions
442 RE r = new RE(re1);
443 say("a*b");
444 boolean result = r.match("aaab");
445 say("aaab = " + result);
446 showParens(r);
447 if (!result) {
448 fail("\"aaab\" doesn't match to precompiled \"a*b\"");
449 }
450
451 result = r.match("b");
452 say("b = " + result);
453 showParens(r);
454 if (!result) {
455 fail("\"b\" doesn't match to precompiled \"a*b\"");
456 }
457
458 result = r.match("c");
459 say("c = " + result);
460 showParens(r);
461 if (result) {
462 fail("\"c\" matches to precompiled \"a*b\"");
463 }
464
465 result = r.match("ccccaaaaab");
466 say("ccccaaaaab = " + result);
467 showParens(r);
468 if (!result) {
469 fail("\"ccccaaaaab\" doesn't match to precompiled \"a*b\"");
470 }
471 }
472
473 private void testSplitAndGrep()
474 {
475 String[] expected = {"xxxx", "xxxx", "yyyy", "zzz"};
476 RE r = new RE("a*b");
477 String[] s = r.split("xxxxaabxxxxbyyyyaaabzzz");
478 for (int i = 0; i < expected.length && i < s.length; i++) {
479 assertEquals("Wrong splitted part", expected[i], s[i]);
480 }
481 assertEquals("Wrong number of splitted parts", expected.length,
482 s.length);
483
484 r = new RE("x+");
485 expected = new String[] {"xxxx", "xxxx"};
486 s = r.grep(s);
487 for (int i = 0; i < s.length; i++)
488 {
489 say("s[" + i + "] = " + s[i]);
490 assertEquals("Grep fails", expected[i], s[i]);
491 }
492 assertEquals("Wrong number of string found by grep", expected.length,
493 s.length);
494 }
495
496 private void testSubst()
497 {
498 RE r = new RE("a*b");
499 String expected = "-foo-garply-wacky-";
500 String actual = r.subst("aaaabfooaaabgarplyaaabwackyb", "-");
501 assertEquals("Wrong result of substitution in \"a*b\"", expected, actual);
502
503 // Test subst() with backreferences
504 r = new RE("http://[\\.\\w\\-\\?/~_@&=%]+");
505 actual = r.subst("visit us: http://www.apache.org!",
506 "1234<a href=\"$0\">$0</a>", RE.REPLACE_BACKREFERENCES);
507 assertEquals("Wrong subst() result", "visit us: 1234<a href=\"http://www.apache.org\">http://www.apache.org</a>!", actual);
508
509 // Test subst() with backreferences without leading characters
510 // before first backreference
511 r = new RE("(.*?)=(.*)");
512 actual = r.subst("variable=value",
513 "$1_test_$212", RE.REPLACE_BACKREFERENCES);
514 assertEquals("Wrong subst() result", "variable_test_value12", actual);
515
516 // Test subst() with NO backreferences
517 r = new RE("^a$");
518 actual = r.subst("a",
519 "b", RE.REPLACE_BACKREFERENCES);
520 assertEquals("Wrong subst() result", "b", actual);
521
522 // Test subst() with NO backreferences
523 r = new RE("^a$", RE.MATCH_MULTILINE);
524 actual = r.subst("\r\na\r\n",
525 "b", RE.REPLACE_BACKREFERENCES);
526 assertEquals("Wrong subst() result", "\r\nb\r\n", actual);
527 }
528
529 public void assertEquals(String message, String expected, String actual)
530 {
531 if (expected != null && !expected.equals(actual)
532 || actual != null && !actual.equals(expected))
533 {
534 fail(message + " (expected \"" + expected
535 + "\", actual \"" + actual + "\")");
536 }
537 }
538
539 public void assertEquals(String message, int expected, int actual)
540 {
541 if (expected != actual) {
542 fail(message + " (expected \"" + expected
543 + "\", actual \"" + actual + "\")");
544 }
545 }
546
547 /**
548 * Converts yesno string to boolean.
549 * @param yesno string representation of expected result
550 * @return true if yesno is "YES", false if yesno is "NO"
551 * stops program otherwise.
552 */
553 private boolean getExpectedResult(String yesno)
554 {
555 if ("NO".equals(yesno))
556 {
557 return false;
558 }
559 else if ("YES".equals(yesno))
560 {
561 return true;
562 }
563 else
564 {
565 // Bad test script
566 die("Test script error!");
567 return false; //to please javac
568 }
569 }
570
571 /**
572 * Finds next test description in a given script.
573 * @param br <code>BufferedReader</code> for a script file
574 * @return strign tag for next test description
575 * @exception IOException if some io problems occured
576 */
577 private String findNextTest(BufferedReader br) throws IOException
578 {
579 String number = "";
580
581 while (br.ready())
582 {
583 number = br.readLine();
584 if (number == null)
585 {
586 break;
587 }
588 number = number.trim();
589 if (number.startsWith("#"))
590 {
591 break;
592 }
593 if (!number.equals(""))
594 {
595 say("Script error. Line = " + number);
596 System.exit(-1);
597 }
598 }
599 return number;
600 }
601
602 /**
603 * Creates testcase for the next test description in the script file.
604 * @param br <code>BufferedReader</code> for script file.
605 * @return a new tescase or null.
606 * @exception IOException if some io problems occured
607 */
608 private RETestCase getNextTestCase(BufferedReader br) throws IOException
609 {
610 // Find next re test case
611 final String tag = findNextTest(br);
612
613 // Are we done?
614 if (!br.ready())
615 {
616 return null;
617 }
618
619 // Get expression
620 final String expr = br.readLine();
621
622 // Get test information
623 final String matchAgainst = br.readLine();
624 final boolean badPattern = "ERR".equals(matchAgainst);
625 boolean shouldMatch = false;
626 int expectedParenCount = 0;
627 String[] expectedParens = null;
628
629 if (!badPattern) {
630 shouldMatch = getExpectedResult(br.readLine().trim());
631 if (shouldMatch) {
632 expectedParenCount = Integer.parseInt(br.readLine().trim());
633 expectedParens = new String[expectedParenCount];
634 for (int i = 0; i < expectedParenCount; i++) {
635 expectedParens[i] = br.readLine();
636 }
637 }
638 }
639
640 return new RETestCase(this, tag, expr, matchAgainst, badPattern,
641 shouldMatch, expectedParens);
642 }
643 }
644
645 final class RETestCase
646 {
647 final private StringBuffer log = new StringBuffer();
648 final private int number;
649 final private String tag; // number from script file
650 final private String pattern;
651 final private String toMatch;
652 final private boolean badPattern;
653 final private boolean shouldMatch;
654 final private String[] parens;
655 final private RETest test;
656 private RE regexp;
657
658 public RETestCase(RETest test, String tag, String pattern,
659 String toMatch, boolean badPattern,
660 boolean shouldMatch, String[] parens)
661 {
662 this.number = ++test.testCount;
663 this.test = test;
664 this.tag = tag;
665 this.pattern = pattern;
666 this.toMatch = toMatch;
667 this.badPattern = badPattern;
668 this.shouldMatch = shouldMatch;
669 if (parens != null) {
670 this.parens = new String[parens.length];
671 for (int i = 0; i < parens.length; i++) {
672 this.parens[i] = parens[i];
673 }
674 } else {
675 this.parens = null;
676 }
677 }
678
679 public void runTest()
680 {
681 test.say(tag + "(" + number + "): " + pattern);
682 if (testCreation()) {
683 testMatch();
684 }
685 }
686
687 boolean testCreation()
688 {
689 try
690 {
691 // Compile it
692 regexp = new RE();
693 regexp.setProgram(test.compiler.compile(pattern));
694 // Expression didn't cause an expected error
695 if (badPattern)
696 {
697 test.fail(log, "Was expected to be an error, but wasn't.");
698 return false;
699 }
700
701 return true;
702 }
703 // Some expressions *should* cause exceptions to be thrown
704 catch (Exception e)
705 {
706 // If it was supposed to be an error, report success and continue
707 if (badPattern)
708 {
709 log.append(" Match: ERR\n");
710 success("Produces an error (" + e.toString() + "), as expected.");
711 return false;
712 }
713
714 // Wasn't supposed to be an error
715 String message = (e.getMessage() == null) ? e.toString() : e.getMessage();
716 test.fail(log, "Produces an unexpected exception \"" + message + "\"");
717 e.printStackTrace();
718 }
719 catch (Error e)
720 {
721 // Internal error happened
722 test.fail(log, "Compiler threw fatal error \"" + e.getMessage() + "\"");
723 e.printStackTrace();
724 }
725
726 return false;
727 }
728
729 private void testMatch()
730 {
731 log.append(" Match against: '" + toMatch + "'\n");
732 // Try regular matching
733 try
734 {
735 // Match against the string
736 boolean result = regexp.match(toMatch);
737 log.append(" Matched: " + (result ? "YES" : "NO") + "\n");
738
739 // Check result, parens, and iterators
740 if (checkResult(result) && (!shouldMatch || checkParens()))
741 {
742 // test match(CharacterIterator, int)
743 // for every CharacterIterator implementation.
744 log.append(" Match using StringCharacterIterator\n");
745 if (!tryMatchUsingCI(new StringCharacterIterator(toMatch)))
746 return;
747
748 log.append(" Match using CharacterArrayCharacterIterator\n");
749 if (!tryMatchUsingCI(new CharacterArrayCharacterIterator(toMatch.toCharArray(), 0, toMatch.length())))
750 return;
751
752 log.append(" Match using StreamCharacterIterator\n");
753 if (!tryMatchUsingCI(new StreamCharacterIterator(new StringBufferInputStream(toMatch))))
754 return;
755
756 log.append(" Match using ReaderCharacterIterator\n");
757 if (!tryMatchUsingCI(new ReaderCharacterIterator(new StringReader(toMatch))))
758 return;
759 }
760 }
761 // Matcher blew it
762 catch(Exception e)
763 {
764 test.fail(log, "Matcher threw exception: " + e.toString());
765 e.printStackTrace();
766 }
767 // Internal error
768 catch(Error e)
769 {
770 test.fail(log, "Matcher threw fatal error \"" + e.getMessage() + "\"");
771 e.printStackTrace();
772 }
773 }
774
775 private boolean checkResult(boolean result)
776 {
777 // Write status
778 if (result == shouldMatch) {
779 success((shouldMatch ? "Matched" : "Did not match")
780 + " \"" + toMatch + "\", as expected:");
781 return true;
782 } else {
783 if (shouldMatch) {
784 test.fail(log, "Did not match \"" + toMatch + "\", when expected to.");
785 } else {
786 test.fail(log, "Matched \"" + toMatch + "\", when not expected to.");
787 }
788 return false;
789 }
790 }
791
792 private boolean checkParens()
793 {
794 // Show subexpression registers
795 if (RETest.showSuccesses)
796 {
797 test.showParens(regexp);
798 }
799
800 log.append(" Paren count: " + regexp.getParenCount() + "\n");
801 if (!assertEquals(log, "Wrong number of parens", parens.length, regexp.getParenCount()))
802 {
803 return false;
804 }
805
806 // Check registers against expected contents
807 for (int p = 0; p < regexp.getParenCount(); p++)
808 {
809 log.append(" Paren " + p + ": " + regexp.getParen(p) + "\n");
810
811 // Compare expected result with actual
812 if ("null".equals(parens[p]) && regexp.getParen(p) == null)
813 {
814 // Consider "null" in test file equal to null
815 continue;
816 }
817 if (!assertEquals(log, "Wrong register " + p, parens[p], regexp.getParen(p)))
818 {
819 return false;
820 }
821 }
822
823 return true;
824 }
825
826 boolean tryMatchUsingCI(CharacterIterator matchAgainst)
827 {
828 try {
829 boolean result = regexp.match(matchAgainst, 0);
830 log.append(" Match: " + (result ? "YES" : "NO") + "\n");
831 return checkResult(result) && (!shouldMatch || checkParens());
832 }
833 // Matcher blew it
834 catch(Exception e)
835 {
836 test.fail(log, "Matcher threw exception: " + e.toString());
837 e.printStackTrace();
838 }
839 // Internal error
840 catch(Error e)
841 {
842 test.fail(log, "Matcher threw fatal error \"" + e.getMessage() + "\"");
843 e.printStackTrace();
844 }
845 return false;
846 }
847
848 public boolean assertEquals(StringBuffer log, String message, String expected, String actual)
849 {
850 if (expected != null && !expected.equals(actual)
851 || actual != null && !actual.equals(expected))
852 {
853 test.fail(log, message + " (expected \"" + expected
854 + "\", actual \"" + actual + "\")");
855 return false;
856 }
857 return true;
858 }
859
860 public boolean assertEquals(StringBuffer log, String message, int expected, int actual)
861 {
862 if (expected != actual) {
863 test.fail(log, message + " (expected \"" + expected
864 + "\", actual \"" + actual + "\")");
865 return false;
866 }
867 return true;
868 }
869
870 /**
871 * Show a success
872 * @param s Success story
873 */
874 void success(String s)
875 {
876 if (RETest.showSuccesses)
877 {
878 test.say("" + RETest.NEW_LINE + "-----------------------" + RETest.NEW_LINE + "");
879 test.say("Expression #" + (number) + " \"" + pattern + "\" ");
880 test.say("Success: " + s);
881 }
882 }
883 }