KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > junit > output > RegexpUtilsTest


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19
20 package org.netbeans.modules.junit.output;
21
22 import java.lang.reflect.Field JavaDoc;
23 import java.lang.reflect.InvocationTargetException JavaDoc;
24 import java.lang.reflect.Method JavaDoc;
25 import java.util.regex.Matcher JavaDoc;
26 import java.util.regex.Pattern JavaDoc;
27 import junit.framework.TestCase;
28
29 /**
30  *
31  * @author Marian Petras
32  */

33 public class RegexpUtilsTest extends TestCase {
34
35     private final Field JavaDoc instRefField;
36     private final Method JavaDoc methodSpecialTrim;
37
38     private RegexpUtils inst;
39
40     public RegexpUtilsTest(String JavaDoc testName) throws NoSuchFieldException JavaDoc,
41                                                    NoSuchMethodException JavaDoc {
42         super(testName);
43         instRefField = RegexpUtils.class.getDeclaredField("instRef");
44         instRefField.setAccessible(true);
45         
46         methodSpecialTrim = RegexpUtils.class.getDeclaredMethod(
47                                     "specialTrim",
48                                     new Class JavaDoc[] {String JavaDoc.class});
49         methodSpecialTrim.setAccessible(true);
50     }
51
52     public void setUp() throws IllegalAccessException JavaDoc {
53         instRefField.set(null, null);
54         
55         inst = RegexpUtils.getInstance();
56     }
57
58     public void testParseTimeMillis() {
59         assertEquals(0, inst.parseTimeMillis("0"));
60         assertEquals(0, inst.parseTimeMillis("00"));
61         assertEquals(1234000, inst.parseTimeMillis("1234"));
62         assertEquals(1234500, inst.parseTimeMillis("1234.5"));
63         assertEquals(1234560, inst.parseTimeMillis("1234.56"));
64         assertEquals(1234567, inst.parseTimeMillis("1234.567"));
65         assertEquals(1234567, inst.parseTimeMillis("1234.5670"));
66         assertEquals(1234567, inst.parseTimeMillis("1234.5671"));
67         assertEquals(1234567, inst.parseTimeMillis("1234.5674"));
68         assertEquals(1234568, inst.parseTimeMillis("1234.5675"));
69         assertEquals(1234568, inst.parseTimeMillis("1234.5676"));
70         assertEquals(1234568, inst.parseTimeMillis("1234.56764"));
71         assertEquals(1234568, inst.parseTimeMillis("1234.56766"));
72         assertEquals(500, inst.parseTimeMillis(".5"));
73         assertEquals(560, inst.parseTimeMillis(".56"));
74         assertEquals(567, inst.parseTimeMillis(".567"));
75         assertEquals(567, inst.parseTimeMillis(".5670"));
76         assertEquals(567, inst.parseTimeMillis(".5671"));
77         assertEquals(567, inst.parseTimeMillis(".5674"));
78         assertEquals(568, inst.parseTimeMillis(".5675"));
79         assertEquals(568, inst.parseTimeMillis(".5676"));
80     }
81     
82     public void testTimeSecsRegex() throws Exception JavaDoc {
83         Pattern JavaDoc pattern = getPattern("TIME_SECS_REGEX");
84         
85         final String JavaDoc[] matchingStrings = new String JavaDoc[] {
86             "0 s",
87             "0 sec",
88             "3 secs",
89             "3 sec(s)",
90             "5 second",
91             "5 seconds",
92             "5 second(s)",
93         };
94         final String JavaDoc[] nonMatchingStrings = new String JavaDoc[] {
95             "0",
96             "0s",
97             "0 ss",
98             "0 s(s)",
99             "0 secss",
100             "0 secs(s)",
101             "0 secondss",
102             "0 seconds(s)"
103         };
104
105         for (int i = 0; i < matchingStrings.length; i++) {
106             String JavaDoc string = matchingStrings[i];
107             assertTrue("should match: " + string,
108                        pattern.matcher(string).matches());
109         }
110         for (int i = 0; i < nonMatchingStrings.length; i++) {
111             String JavaDoc string = nonMatchingStrings[i];
112             assertFalse("should not match: " + string,
113                         pattern.matcher(string).matches());
114         }
115     }
116     
117     public void testTestcaseIssueRegex() throws Exception JavaDoc {
118         Pattern JavaDoc pattern = getPattern("TESTCASE_ISSUE_REGEX");
119
120         final String JavaDoc[] matchingStrings = new String JavaDoc[] {
121             "FAILED",
122             "Caused an ERROR",
123             "error",
124             " FAILED",
125             "\t \t FAILED",
126             " \t \tFAILED",
127             "\t \t FAILED ",
128             " \t \tFAILED ",
129             "xxxxx ErRoR yyy"
130         };
131         final String JavaDoc[] nonMatchingStrings = new String JavaDoc[] {
132             "failed",
133             "Failed",
134             "x FAILED",
135             "xFAILED",
136             "FAILEDx",
137             "mistakeerror",
138             "mistake errors",
139         };
140
141         for (int i = 0; i < matchingStrings.length; i++) {
142             String JavaDoc string = matchingStrings[i];
143             assertTrue("should match: " + string,
144                        pattern.matcher(string).matches());
145         }
146         for (int i = 0; i < nonMatchingStrings.length; i++) {
147             String JavaDoc string = nonMatchingStrings[i];
148             assertFalse("should not match: " + string,
149                         pattern.matcher(string).matches());
150         }
151     }
152     
153     public void testTestcaseHeaderPlainRegex() throws Exception JavaDoc {
154         Pattern JavaDoc pattern = getPattern("TESTCASE_HEADER_PLAIN_REGEX");
155
156         final String JavaDoc[] matchingStrings = new String JavaDoc[] {
157             "testComputeSum took 0.002 sec",
158             "testComputeSum took 0 sec",
159             "testComputeSum took 0.002 s",
160             " testComputeSum took 0.002 sec",
161             " testComputeSum took 0.002 sec",
162             "\ttestComputeSum took 0.002 sec",
163             "\t\t\testComputeSum took 0.002 sec",
164             " \t\t testComputeSum took 0.002 sec",
165             "\t\t testComputeSum took 0.002 sec",
166             "test took 12 seconds",
167             "test\ttook 12 seconds",
168             "test\t\ttook .5 seconds",
169             "test\t took .5 seconds",
170             "test took .5 seconds",
171             "test12 took 12 secs"
172         };
173         final String JavaDoc[] nonMatchingStrings = new String JavaDoc[] {
174             "12test took 12 seconds",
175             "test took seconds",
176             "test took3 seconds",
177             "test took 3seconds",
178             "test took3seconds",
179             "test took . seconds"
180         };
181
182         for (int i = 0; i < matchingStrings.length; i++) {
183             String JavaDoc string = matchingStrings[i];
184             assertTrue("should match: " + string,
185                        pattern.matcher(string).matches());
186         }
187         for (int i = 0; i < nonMatchingStrings.length; i++) {
188             String JavaDoc string = nonMatchingStrings[i];
189             assertFalse("should not match: " + string,
190                         pattern.matcher(string).matches());
191         }
192     }
193     
194     public void testTestcaseHeaderBriefRegex() throws Exception JavaDoc {
195         Pattern JavaDoc pattern = getPattern("TESTCASE_HEADER_BRIEF_REGEX");
196
197         final String JavaDoc[] matchingStrings = new String JavaDoc[] {
198             "testMain(javapplication2.MainTest): FAILED",
199             "testMain(javapplication2.MainTest): Caused an ERROR",
200             "testMain(MainTest): FAILED",
201             " testMain(javapplication2.MainTest): FAILED",
202             "testMain(javapplication2.MainTest) :FAILED",
203             "testMain(javapplication2.MainTest) : FAILED",
204             "testMain(javapplication2.MainTest): mistake error"
205         };
206         final String JavaDoc[] nonMatchingStrings = new String JavaDoc[] {
207             "testMain(javapplication2.MainTest)",
208             "(javapplication2.MainTest): FAILED",
209             "testMain(javapplication2.MainTest): Failed",
210             "testMain(javapplication2.MainTest): mistake",
211             "testMain(javapplication2.MainTest): errors",
212             "testMain(javapplication2.MainTest): mistakeerror",
213             "testMain(javapplication2.MainTest): mistake errors",
214             "testMain(javapplication2.): FAILED",
215             "testMain(.MainTest): FAILED",
216             "testMain(javapplication2..MainTest): FAILED",
217             "testMain(2.MainTest): FAILED",
218             "testMain(javapplication2.2): FAILED"
219         };
220
221         for (int i = 0; i < matchingStrings.length; i++) {
222             String JavaDoc string = matchingStrings[i];
223             assertTrue("should match: " + string,
224                        pattern.matcher(string).matches());
225         }
226         for (int i = 0; i < nonMatchingStrings.length; i++) {
227             String JavaDoc string = nonMatchingStrings[i];
228             assertFalse("should not match: " + string,
229                         pattern.matcher(string).matches());
230         }
231     }
232     
233     public void testTestcaseExceptionRegex() throws Exception JavaDoc {
234         Pattern JavaDoc pattern = getPattern("TESTCASE_EXCEPTION_REGEX");
235         
236         final String JavaDoc[] matchingStrings = new String JavaDoc[] {
237                 "junit.framework.AssertionFailedException",
238                 "junit.framework.AssertionFailedException: The test case is empty.",
239                 "java.lang.NullPointerException",
240                 "java.lang.Exception",
241                 "java.lang.Throwable",
242                 "MySpecialException",
243                 "MySpecialError",
244                 "foo.Exception",
245                 "foo.Error",
246                 "foo.bar.Exception",
247                 "foo.bar.Error" };
248         final String JavaDoc[] nonMatchingStrings = new String JavaDoc[] {
249                 "Exception",
250                 "Error",
251                 "Throwable",
252                 "mypackage.Throwable",
253                 "foo.bar.Throwable",
254                 ".foo",
255                 ".Exception",
256                 ".Error",
257                 ".foo.Exception",
258                 ".foo.Error",
259                 "Exception.",
260                 "Error.",
261                 "foo.Exception.",
262                 "foo.Error.",
263                 "foo.bar.Exception.",
264                 "foo.bar.Error.",
265                 "foo..bar.Exception",
266                 "foo..bar.Error",
267                 "junit.framework.AssertionFailedException It failed" };
268         for (int i = 0; i < matchingStrings.length; i++) {
269             String JavaDoc string = matchingStrings[i];
270             assertTrue("should match: " + string,
271                        pattern.matcher(string).matches());
272         }
273         for (int i = 0; i < nonMatchingStrings.length; i++) {
274             String JavaDoc string = nonMatchingStrings[i];
275             assertFalse("should not match: " + string,
276                         pattern.matcher(string).matches());
277         }
278                 
279         Matcher JavaDoc matcher;
280                 
281         matcher = pattern.matcher("java.lang.NullPointerException");
282         assertTrue(matcher.matches());
283         assertEquals("java.lang.NullPointerException", matcher.group(1));
284         assertNull(matcher.group(2));
285
286         matcher = pattern.matcher("java.lang.NullPointerException:");
287         assertTrue(matcher.matches());
288         assertEquals("java.lang.NullPointerException", matcher.group(1));
289         assertEquals("", matcher.group(2));
290
291         matcher = pattern.matcher("java.lang.NullPointerException : Failed");
292         assertTrue(matcher.matches());
293         assertEquals("java.lang.NullPointerException", matcher.group(1));
294         assertEquals("Failed", matcher.group(2));
295     }
296     
297     public void testCallstackLineRegex() throws Exception JavaDoc{
298         Pattern JavaDoc pattern = getPattern("CALLSTACK_LINE_REGEX");
299         
300         final String JavaDoc[] matchingStrings = new String JavaDoc[] {
301             " at javaapplication.MainTest.test",
302             " at javaapplication.MainTest.test",
303             " at javaapplication.MainTest.test",
304             "\tat javaapplication.MainTest.test",
305             "\t\tat javaapplication.MainTest.test",
306             "[catch] at javaapplication.MainTest.test",
307             " [catch] at javaapplication.MainTest.test",
308             " [catch] at javaapplication.MainTest.test",
309             " [catch] at javaapplication.MainTest.test",
310             "\t[catch] at javaapplication.MainTest.test",
311             "\t [catch] at javaapplication.MainTest.test",
312             " \t[catch] at javaapplication.MainTest.test",
313             "\t [catch] at javaapplication.MainTest.test",
314             " \t [catch] at javaapplication.MainTest.test",
315             " \t[catch] at javaapplication.MainTest.test",
316             "\t [catch] at javaapplication.MainTest.test",
317             " \t [catch] at javaapplication.MainTest.test",
318             " \t [catch] at javaapplication.MainTest.test",
319             " \t[catch] at javaapplication.MainTest.test",
320             " at MainTest.test",
321             " at javaapplication.MainTest.test(a)",
322             " at javaapplication.MainTest.test (a)",
323             " at javaapplication.MainTest.test (Compiled)",
324             " at javaapplication.MainTest.test (Native method)",
325             " at javaapplication.MainTest.test (MainTest.java)",
326             " at javaapplication.MainTest.test (MainTest.java:32)",
327             " at javaapplication.MainTest.test(MainTest.java:32)"
328         };
329         final String JavaDoc[] nonMatchingStrings = new String JavaDoc[] {
330             "javaapplication.MainTest.test",
331             " javaapplication.MainTest.test",
332             "at javaapplication.MainTest.test",
333             " at javaapplication.MainTest.test",
334             " at javaapplication.MainTest.test",
335             "\t at javaapplication.MainTest.test",
336             " \tat javaapplication.MainTest.test",
337             "\t at javaapplication.MainTest.test",
338             " \t at javaapplication.MainTest.test",
339             " \tat javaapplication.MainTest.test",
340             "\t\t at javaapplication.MainTest.test",
341             "\t \tat javaapplication.MainTest.test",
342             " \t\tat javaapplication.MainTest.test",
343             "\t\t at javaapplication.MainTest.test",
344             "\t \t at javaapplication.MainTest.test",
345             "\t \tat javaapplication.MainTest.test",
346             " \t\t at javaapplication.MainTest.test",
347             " \t \tat javaapplication.MainTest.test",
348             " \t\tat javaapplication.MainTest.test",
349             "\t\t[catch] at javaapplication.MainTest.test",
350             " \t\t[catch] at javaapplication.MainTest.test",
351             "\t \t[catch] at javaapplication.MainTest.test",
352             "\t\t [catch] at javaapplication.MainTest.test",
353             " at test",
354             " at javaapplication.%dfsd",
355             " at 2application.MainTest",
356             " at javaapplication.MainTest.test()",
357             " at javaapplication.MainTest.test ()",
358             " at javaapplication.MainTest.test (a)",
359             " at javaapplication.MainTest.test xyz",
360             " at javaapplication.MainTest.test (abc) x",
361             " at javaapplication.MainTest.test (abc) (de)",
362             " at javaapplication.MainTest.test (ab(cd)",
363             " at javaapplication.MainTest.test (ab)cd)",
364             " at javaapplication.MainTest.test (ab(cd))"
365         };
366
367         for (int i = 0; i < matchingStrings.length; i++) {
368             String JavaDoc string = matchingStrings[i];
369             assertTrue("should match: " + string,
370                        pattern.matcher(string).matches());
371         }
372         for (int i = 0; i < nonMatchingStrings.length; i++) {
373             String JavaDoc string = nonMatchingStrings[i];
374             assertFalse("should not match: " + string,
375                         pattern.matcher(string).matches());
376         }
377     }
378     
379     public void testXmlDeclRegex() throws Exception JavaDoc {
380         Pattern JavaDoc pattern = getPattern("XML_DECL_REGEX");
381         
382         final String JavaDoc[] matchingStrings = new String JavaDoc[] {
383             "<?xml version=\"1.0\"?>",
384             "<?xml version=\"1.0\"?>",
385             "<?xml\tversion=\"1.0\"?>",
386             "<?xml\t\t version=\"1.0\"?>",
387             "<?xml version =\"1.0\"?>",
388             "<?xml version =\"1.0\"?>",
389             "<?xml version= \"1.0\"?>",
390             "<?xml version= \"1.0\"?>",
391             "<?xml version = \"1.0\"?>",
392             "<?xml version \t=\t \"1.0\"?>",
393             "<?xml version=\"1.0\" encoding=\"abc\"?>",
394             "<?xml version=\"1.0\" encoding=\'abc\'?>",
395             "<?xml version=\"1.0\"\tencoding=\"abc\"?>",
396             "<?xml version=\"1.0\" encoding=\"abc\"?>",
397             "<?xml version=\"1.0\"\t\tencoding=\"abc\"?>",
398             "<?xml version=\"1.0\" \tencoding=\"abc\"?>",
399             "<?xml version=\"1.0\"\t encoding=\"abc\"?>",
400             "<?xml version=\"1.0\" encoding =\"abc\"?>",
401             "<?xml version=\"1.0\" encoding= \"abc\"?>",
402             "<?xml version=\"1.0\" encoding\t=\t\"abc\"?>",
403             "<?xml version=\"1.0\" encoding\t = \t\"abc\"?>",
404             "<?xml version=\"1.0\" encoding=\"ab1c\"?>",
405             "<?xml version=\"1.0\" encoding=\"ab.c\"?>",
406             "<?xml version=\"1.0\" encoding=\"ab_c\"?>",
407             "<?xml version=\"1.0\" encoding=\"ab-c\"?>",
408
409             "<?xml version=\"1.0\" standalone=\"yes\"?>",
410             "<?xml version=\"1.0\" standalone=\'yes\'?>",
411             "<?xml version=\"1.0\" standalone=\"no\"?>",
412             "<?xml version=\"1.0\" standalone=\'no\'?>",
413             "<?xml version=\"1.0\"\tstandalone=\"yes\"?>",
414             "<?xml version=\"1.0\" standalone=\"yes\"?>",
415             "<?xml version=\"1.0\"\t\tstandalone=\"yes\"?>",
416             "<?xml version=\"1.0\" \tstandalone=\"yes\"?>",
417             "<?xml version=\"1.0\"\t standalone=\"yes\"?>",
418             "<?xml version=\"1.0\" standalone =\"yes\"?>",
419             "<?xml version=\"1.0\" standalone= \"yes\"?>",
420             "<?xml version=\"1.0\" standalone\t=\t\"yes\"?>",
421             "<?xml version=\"1.0\" standalone\t = \t\"yes\"?>",
422
423             "<?xml version=\"1.0\" encoding=\"abc\" standalone=\"yes\"?>",
424             "<?xml version=\"1.0\" encoding=\"abc\" standalone=\'yes\'?>",
425             "<?xml version=\"1.0\" encoding=\'abc\' standalone=\"yes\"?>",
426             "<?xml version=\"1.0\" encoding=\'abc\' standalone=\'yes\'?>",
427                     
428             "<?xml version=\"1.0\" encoding=\"abc\" standalone=\"yes\" ?>",
429             "<?xml version=\"1.0\" encoding=\"abc\" standalone=\"yes\"\t?>"
430         };
431         final String JavaDoc[] nonMatchingStrings = new String JavaDoc[] {
432             "<?xml?>",
433             "<?xml ?>",
434             "<?xml version=\"1.1\"?>",
435             "<?xmlversion=\"1.0\"?>",
436             "<Uxml version=\"1.0\"?>",
437             "<?xml version=\"1.0\"U>",
438             "<?xml version=\"1.0\"?> ",
439             "<?xml version=\"1.0\"?>\t",
440             "xml version=\"1.0\"?>",
441             "<?xml version=\"1.0>",
442             "<?xml version=\"1.0\"encoding=\"abc\"?>",
443             "<?xml version=\"1.0\" encoding=\"ab%\"?>",
444             "<?xml version=\"1.0\" encoding=\"1abc\"?>",
445             "<?xml version=\"1.0\" encoding=\".abc\"?>",
446             "<?xml version=\"1.0\" encoding=\"_abc\"?>",
447             "<?xml version=\"1.0\" encoding=\"-abc\"?>",
448             "<?xml version=\"1.0\"standalone=yes?>",
449             "<?xml version=\"1.0\" standalone=yes>",
450             "<?xml version=\"1.0\" standalone=\'yes\"?>",
451             "<?xml version=\"1.0\" standalone=\"yes\'?>",
452             "<?xml version=\"1.0\" standalone=\"yes?>",
453             "<?xml version=\"1.0\" standalone=yes\"?>",
454             "<?xml version=\"1.0\" standalone=\'yes?>",
455             "<?xml version=\"1.0\" standalone=yes\'?>",
456             "<?xml version=\"1.0\" standalone=\"maybe\"?>",
457             "<?xml version=\"1.0\" encoding=\"abc\" standalone=\'yes\"?>",
458             "<?xml version=\"1.0\" encoding=\'abc\" standalone=\"yes\"?>"
459         };
460
461         for (int i = 0; i < matchingStrings.length; i++) {
462             String JavaDoc string = matchingStrings[i];
463             assertTrue("should match: " + string,
464                        pattern.matcher(string).matches());
465         }
466         for (int i = 0; i < nonMatchingStrings.length; i++) {
467             String JavaDoc string = nonMatchingStrings[i];
468             assertFalse("should not match: " + string,
469                         pattern.matcher(string).matches());
470         }
471     }
472     
473     /**
474      */

475     public void testSpecialTrim() throws IllegalAccessException JavaDoc,
476                                          InvocationTargetException JavaDoc {
477         assertSame("", specialTrim(""));
478         assertSame("abcde", specialTrim("abcde"));
479         assertSame("ab\tc de", specialTrim("ab\tc de"));
480         assertSame("ab c\tde", specialTrim("ab c\tde"));
481         assertEquals("", specialTrim(" "));
482         assertEquals("", specialTrim("\t\t"));
483         assertEquals("abcde", specialTrim(" abcde"));
484         assertEquals("abcde", specialTrim("abcde "));
485         assertEquals("abcde", specialTrim(" abcde "));
486         assertEquals("ab\tc de", specialTrim(" ab\tc de"));
487         assertEquals("ab c\tde", specialTrim("\tab c\tde"));
488         assertEquals("ab\tc de", specialTrim("ab\tc de "));
489         assertEquals("ab c\tde", specialTrim("ab c\tde\t"));
490     }
491     
492     
493     private Pattern JavaDoc getPattern(String JavaDoc fieldName) throws Exception JavaDoc {
494         return Pattern.compile(getRegex(fieldName));
495     }
496     
497     private String JavaDoc getRegex(String JavaDoc fieldName) throws Exception JavaDoc {
498         Field JavaDoc regexField = RegexpUtils.class.getDeclaredField(fieldName);
499         regexField.setAccessible(true);
500         return (String JavaDoc) regexField.get(null);
501     }
502     
503     /**
504      */

505     private String JavaDoc specialTrim(String JavaDoc str) throws IllegalAccessException JavaDoc,
506                                                   InvocationTargetException JavaDoc {
507         Object JavaDoc result = methodSpecialTrim.invoke(null, new Object JavaDoc[] {str});
508         return (String JavaDoc) result;
509     }
510
511 }
512
Popular Tags