1 /*
2 * Copyright (c) 1999, 2020, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /**
25 * @test
26 * @summary tests RegExp framework (use -Dseed=X to set PRNG seed)
27 * @author Mike McCloskey
28 * @bug 4481568 4482696 4495089 4504687 4527731 4599621 4631553 4619345
29 * 4630911 4672616 4711773 4727935 4750573 4792284 4803197 4757029 4808962
30 * 4872664 4803179 4892980 4900747 4945394 4938995 4979006 4994840 4997476
31 * 5013885 5003322 4988891 5098443 5110268 6173522 4829857 5027748 6376940
32 * 6358731 6178785 6284152 6231989 6497148 6486934 6233084 6504326 6635133
33 * 6350801 6676425 6878475 6919132 6931676 6948903 6990617 7014645 7039066
34 * 7067045 7014640 7189363 8007395 8013252 8013254 8012646 8023647 6559590
35 * 8027645 8035076 8039124 8035975 8074678 6854417 8143854 8147531 7071819
36 * 8151481 4867170 7080302 6728861 6995635 6736245 4916384 6328855 6192895
37 * 6345469 6988218 6693451 7006761 8140212 8143282 8158482 8176029 8184706
38 * 8194667 8197462 8184692 8221431 8224789 8228352 8230829 8236034
39 *
40 * @library /test/lib
41 * @library /lib/testlibrary/java/lang
42 * @build jdk.test.lib.RandomFactory
43 * @run main RegExTest
44 * @key randomness
45 */
46
47 import java.io.BufferedReader;
48 import java.io.ByteArrayInputStream;
49 import java.io.ByteArrayOutputStream;
50 import java.io.File;
51 import java.io.FileInputStream;
52 import java.io.InputStreamReader;
53 import java.io.ObjectInputStream;
54 import java.io.ObjectOutputStream;
55 import java.math.BigInteger;
56 import java.nio.CharBuffer;
57 import java.nio.file.Files;
58 import java.util.ArrayList;
59 import java.util.Arrays;
60 import java.util.List;
61 import java.util.Random;
62 import java.util.Scanner;
63 import java.util.function.Function;
64 import java.util.function.Predicate;
65 import java.util.regex.Matcher;
66 import java.util.regex.MatchResult;
67 import java.util.regex.Pattern;
68 import java.util.regex.PatternSyntaxException;
69 import jdk.test.lib.RandomFactory;
70
71 /**
72 * This is a test class created to check the operation of
73 * the Pattern and Matcher classes.
74 */
75 public class RegExTest {
76
77 private static Random generator = RandomFactory.getRandom();
78 private static boolean failure = false;
79 private static int failCount = 0;
80 private static String firstFailure = null;
81
82 /**
83 * Main to interpret arguments and run several tests.
84 *
85 */
86 public static void main(String[] args) throws Exception {
87 // Most of the tests are in a file
88 processFile("TestCases.txt");
89 //processFile("PerlCases.txt");
90 processFile("BMPTestCases.txt");
91 processFile("SupplementaryTestCases.txt");
92
93 // These test many randomly generated char patterns
94 bm();
95 slice();
96
97 // These are hard to put into the file
98 escapes();
99 blankInput();
100
101 // Substitition tests on randomly generated sequences
102 globalSubstitute();
103 stringbufferSubstitute();
104 stringbuilderSubstitute();
105
106 substitutionBasher();
107 substitutionBasher2();
108
109 // Canonical Equivalence
110 ceTest();
111
112 // Anchors
113 anchorTest();
114
115 // boolean match calls
116 matchesTest();
117 lookingAtTest();
118
119 // Pattern API
120 patternMatchesTest();
121
122 // Misc
123 lookbehindTest();
124 nullArgumentTest();
125 backRefTest();
126 groupCaptureTest();
127 caretTest();
128 charClassTest();
129 emptyPatternTest();
130 findIntTest();
131 group0Test();
132 longPatternTest();
133 octalTest();
134 ampersandTest();
135 negationTest();
136 splitTest();
137 appendTest();
138 caseFoldingTest();
139 commentsTest();
140 unixLinesTest();
141 replaceFirstTest();
142 gTest();
143 zTest();
144 serializeTest();
145 reluctantRepetitionTest();
146 multilineDollarTest();
147 dollarAtEndTest();
148 caretBetweenTerminatorsTest();
149 // This RFE rejected in Tiger numOccurrencesTest();
150 javaCharClassTest();
151 nonCaptureRepetitionTest();
152 notCapturedGroupCurlyMatchTest();
153 escapedSegmentTest();
154 literalPatternTest();
155 literalReplacementTest();
156 regionTest();
157 toStringTest();
158 negatedCharClassTest();
159 findFromTest();
160 boundsTest();
161 unicodeWordBoundsTest();
162 caretAtEndTest();
163 wordSearchTest();
164 hitEndTest();
165 toMatchResultTest();
166 toMatchResultTest2();
167 surrogatesInClassTest();
168 removeQEQuotingTest();
169 namedGroupCaptureTest();
170 nonBmpClassComplementTest();
171 unicodePropertiesTest();
172 unicodeHexNotationTest();
173 unicodeClassesTest();
174 unicodeCharacterNameTest();
175 horizontalAndVerticalWSTest();
176 linebreakTest();
177 branchTest();
178 groupCurlyNotFoundSuppTest();
179 groupCurlyBackoffTest();
180 patternAsPredicate();
181 patternAsMatchPredicate();
182 invalidFlags();
183 embeddedFlags();
184 grapheme();
185 expoBacktracking();
186 invalidGroupName();
187 illegalRepetitionRange();
188 surrogatePairWithCanonEq();
189
190 if (failure) {
191 throw new
192 RuntimeException("RegExTest failed, 1st failure: " +
193 firstFailure);
194 } else {
195 System.err.println("OKAY: All tests passed.");
196 }
197 }
198
199 // Utility functions
200
201 private static String getRandomAlphaString(int length) {
202 StringBuffer buf = new StringBuffer(length);
203 for (int i=0; i<length; i++) {
204 char randChar = (char)(97 + generator.nextInt(26));
205 buf.append(randChar);
206 }
207 return buf.toString();
208 }
209
210 private static void check(Matcher m, String expected) {
211 m.find();
212 if (!m.group().equals(expected))
213 failCount++;
214 }
215
216 private static void check(Matcher m, String result, boolean expected) {
217 m.find();
218 if (m.group().equals(result) != expected)
219 failCount++;
220 }
221
222 private static void check(Pattern p, String s, boolean expected) {
223 if (p.matcher(s).find() != expected)
224 failCount++;
225 }
226
227 private static void check(String p, String s, boolean expected) {
228 Matcher matcher = Pattern.compile(p).matcher(s);
229 if (matcher.find() != expected)
230 failCount++;
231 }
232
233 private static void check(String p, char c, boolean expected) {
234 String propertyPattern = expected ? "\\p" + p : "\\P" + p;
235 Pattern pattern = Pattern.compile(propertyPattern);
236 char[] ca = new char[1]; ca[0] = c;
237 Matcher matcher = pattern.matcher(new String(ca));
238 if (!matcher.find())
239 failCount++;
240 }
241
242 private static void check(String p, int codePoint, boolean expected) {
243 String propertyPattern = expected ? "\\p" + p : "\\P" + p;
244 Pattern pattern = Pattern.compile(propertyPattern);
245 char[] ca = Character.toChars(codePoint);
246 Matcher matcher = pattern.matcher(new String(ca));
247 if (!matcher.find())
248 failCount++;
249 }
250
251 private static void check(String p, int flag, String input, String s,
252 boolean expected)
253 {
254 Pattern pattern = Pattern.compile(p, flag);
255 Matcher matcher = pattern.matcher(input);
256 if (expected)
257 check(matcher, s, expected);
258 else
259 check(pattern, input, false);
260 }
261
262 private static void report(String testName) {
263 int spacesToAdd = 30 - testName.length();
264 StringBuffer paddedNameBuffer = new StringBuffer(testName);
265 for (int i=0; i<spacesToAdd; i++)
266 paddedNameBuffer.append(" ");
267 String paddedName = paddedNameBuffer.toString();
268 System.err.println(paddedName + ": " +
269 (failCount==0 ? "Passed":"Failed("+failCount+")"));
270 if (failCount > 0) {
271 failure = true;
272
273 if (firstFailure == null) {
274 firstFailure = testName;
275 }
276 }
277
278 failCount = 0;
279 }
280
281 /**
282 * Converts ASCII alphabet characters [A-Za-z] in the given 's' to
283 * supplementary characters. This method does NOT fully take care
284 * of the regex syntax.
285 */
286 private static String toSupplementaries(String s) {
287 int length = s.length();
288 StringBuffer sb = new StringBuffer(length * 2);
289
290 for (int i = 0; i < length; ) {
291 char c = s.charAt(i++);
292 if (c == '\\') {
293 sb.append(c);
294 if (i < length) {
295 c = s.charAt(i++);
296 sb.append(c);
297 if (c == 'u') {
298 // assume no syntax error
299 sb.append(s.charAt(i++));
300 sb.append(s.charAt(i++));
301 sb.append(s.charAt(i++));
302 sb.append(s.charAt(i++));
303 }
304 }
305 } else if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
306 sb.append('\ud800').append((char)('\udc00'+c));
307 } else {
308 sb.append(c);
309 }
310 }
311 return sb.toString();
312 }
313
314 // Regular expression tests
315
316 // This is for bug 6178785
317 // Test if an expected NPE gets thrown when passing in a null argument
318 private static boolean check(Runnable test) {
319 try {
320 test.run();
321 failCount++;
322 return false;
323 } catch (NullPointerException npe) {
324 return true;
325 }
326 }
327
328 private static void nullArgumentTest() {
329 check(() -> Pattern.compile(null));
330 check(() -> Pattern.matches(null, null));
331 check(() -> Pattern.matches("xyz", null));
332 check(() -> Pattern.quote(null));
333 check(() -> Pattern.compile("xyz").split(null));
334 check(() -> Pattern.compile("xyz").matcher(null));
335
336 final Matcher m = Pattern.compile("xyz").matcher("xyz");
337 m.matches();
338 check(() -> m.appendTail((StringBuffer) null));
339 check(() -> m.appendTail((StringBuilder)null));
340 check(() -> m.replaceAll((String) null));
341 check(() -> m.replaceAll((Function<MatchResult, String>)null));
342 check(() -> m.replaceFirst((String)null));
343 check(() -> m.replaceFirst((Function<MatchResult, String>) null));
344 check(() -> m.appendReplacement((StringBuffer)null, null));
345 check(() -> m.appendReplacement((StringBuilder)null, null));
346 check(() -> m.reset(null));
347 check(() -> Matcher.quoteReplacement(null));
348 //check(() -> m.usePattern(null));
349
350 report("Null Argument");
351 }
352
353 // This is for bug6635133
354 // Test if surrogate pair in Unicode escapes can be handled correctly.
355 private static void surrogatesInClassTest() throws Exception {
356 Pattern pattern = Pattern.compile("[\\ud834\\udd21-\\ud834\\udd24]");
357 Matcher matcher = pattern.matcher("\ud834\udd22");
358 if (!matcher.find())
359 failCount++;
360
361 report("Surrogate pair in Unicode escape");
362 }
363
364 // This is for bug6990617
365 // Test if Pattern.RemoveQEQuoting works correctly if the octal unicode
366 // char encoding is only 2 or 3 digits instead of 4 and the first quoted
367 // char is an octal digit.
368 private static void removeQEQuotingTest() throws Exception {
369 Pattern pattern =
370 Pattern.compile("\\011\\Q1sometext\\E\\011\\Q2sometext\\E");
371 Matcher matcher = pattern.matcher("\t1sometext\t2sometext");
372 if (!matcher.find())
373 failCount++;
374
375 report("Remove Q/E Quoting");
376 }
377
378 // This is for bug 4988891
379 // Test toMatchResult to see that it is a copy of the Matcher
380 // that is not affected by subsequent operations on the original
381 private static void toMatchResultTest() throws Exception {
382 Pattern pattern = Pattern.compile("squid");
383 Matcher matcher = pattern.matcher(
384 "agiantsquidofdestinyasmallsquidoffate");
385 matcher.find();
386 int matcherStart1 = matcher.start();
387 MatchResult mr = matcher.toMatchResult();
388 if (mr == matcher)
389 failCount++;
390 int resultStart1 = mr.start();
391 if (matcherStart1 != resultStart1)
392 failCount++;
393 matcher.find();
394 int matcherStart2 = matcher.start();
395 int resultStart2 = mr.start();
396 if (matcherStart2 == resultStart2)
397 failCount++;
398 if (resultStart1 != resultStart2)
399 failCount++;
400 MatchResult mr2 = matcher.toMatchResult();
401 if (mr == mr2)
402 failCount++;
403 if (mr2.start() != matcherStart2)
404 failCount++;
405 report("toMatchResult is a copy");
406 }
407
408 private static void checkExpectedISE(Runnable test) {
409 try {
410 test.run();
411 failCount++;
412 } catch (IllegalStateException x) {
413 } catch (IndexOutOfBoundsException xx) {
414 failCount++;
415 }
416 }
417
418 private static void checkExpectedIOOE(Runnable test) {
419 try {
420 test.run();
421 failCount++;
422 } catch (IndexOutOfBoundsException x) {}
423 }
424
425 // This is for bug 8074678
426 // Test the result of toMatchResult throws ISE if no match is availble
427 private static void toMatchResultTest2() throws Exception {
428 Matcher matcher = Pattern.compile("nomatch").matcher("hello world");
429 matcher.find();
430 MatchResult mr = matcher.toMatchResult();
431
432 checkExpectedISE(() -> mr.start());
433 checkExpectedISE(() -> mr.start(2));
434 checkExpectedISE(() -> mr.end());
435 checkExpectedISE(() -> mr.end(2));
436 checkExpectedISE(() -> mr.group());
437 checkExpectedISE(() -> mr.group(2));
438
439 matcher = Pattern.compile("(match)").matcher("there is a match");
440 matcher.find();
441 MatchResult mr2 = matcher.toMatchResult();
442 checkExpectedIOOE(() -> mr2.start(2));
443 checkExpectedIOOE(() -> mr2.end(2));
444 checkExpectedIOOE(() -> mr2.group(2));
445
446 report("toMatchResult2 appropriate exceptions");
447 }
448
449 // This is for bug 5013885
450 // Must test a slice to see if it reports hitEnd correctly
451 private static void hitEndTest() throws Exception {
452 // Basic test of Slice node
453 Pattern p = Pattern.compile("^squidattack");
454 Matcher m = p.matcher("squack");
455 m.find();
456 if (m.hitEnd())
457 failCount++;
458 m.reset("squid");
459 m.find();
460 if (!m.hitEnd())
461 failCount++;
462
463 // Test Slice, SliceA and SliceU nodes
464 for (int i=0; i<3; i++) {
465 int flags = 0;
466 if (i==1) flags = Pattern.CASE_INSENSITIVE;
467 if (i==2) flags = Pattern.UNICODE_CASE;
468 p = Pattern.compile("^abc", flags);
469 m = p.matcher("ad");
470 m.find();
471 if (m.hitEnd())
472 failCount++;
473 m.reset("ab");
474 m.find();
475 if (!m.hitEnd())
476 failCount++;
477 }
478
479 // Test Boyer-Moore node
480 p = Pattern.compile("catattack");
481 m = p.matcher("attack");
482 m.find();
483 if (!m.hitEnd())
484 failCount++;
485
486 p = Pattern.compile("catattack");
487 m = p.matcher("attackattackattackcatatta");
488 m.find();
489 if (!m.hitEnd())
490 failCount++;
491
492 // 8184706: Matching u+0d at EOL against \R should hit-end
493 p = Pattern.compile("...\\R");
494 m = p.matcher("cat" + (char)0x0a);
495 m.find();
496 if (m.hitEnd())
497 failCount++;
498
499 m = p.matcher("cat" + (char)0x0d);
500 m.find();
501 if (!m.hitEnd())
502 failCount++;
503
504 m = p.matcher("cat" + (char)0x0d + (char)0x0a);
505 m.find();
506 if (m.hitEnd())
507 failCount++;
508
509 report("hitEnd");
510 }
511
512 // This is for bug 4997476
513 // It is weird code submitted by customer demonstrating a regression
514 private static void wordSearchTest() throws Exception {
515 String testString = new String("word1 word2 word3");
516 Pattern p = Pattern.compile("\\b");
517 Matcher m = p.matcher(testString);
518 int position = 0;
519 int start = 0;
520 while (m.find(position)) {
521 start = m.start();
522 if (start == testString.length())
523 break;
524 if (m.find(start+1)) {
525 position = m.start();
526 } else {
527 position = testString.length();
528 }
529 if (testString.substring(start, position).equals(" "))
530 continue;
531 if (!testString.substring(start, position-1).startsWith("word"))
532 failCount++;
533 }
534 report("Customer word search");
535 }
536
537 // This is for bug 4994840
538 private static void caretAtEndTest() throws Exception {
539 // Problem only occurs with multiline patterns
540 // containing a beginning-of-line caret "^" followed
541 // by an expression that also matches the empty string.
542 Pattern pattern = Pattern.compile("^x?", Pattern.MULTILINE);
543 Matcher matcher = pattern.matcher("\r");
544 matcher.find();
545 matcher.find();
546 report("Caret at end");
547 }
548
549 // This test is for 4979006
550 // Check to see if word boundary construct properly handles unicode
551 // non spacing marks
552 private static void unicodeWordBoundsTest() throws Exception {
553 String spaces = " ";
554 String wordChar = "a";
555 String nsm = "\u030a";
556
557 assert (Character.getType('\u030a') == Character.NON_SPACING_MARK);
558
559 Pattern pattern = Pattern.compile("\\b");
560 Matcher matcher = pattern.matcher("");
561 // S=other B=word character N=non spacing mark .=word boundary
562 // SS.BB.SS
563 String input = spaces + wordChar + wordChar + spaces;
564 twoFindIndexes(input, matcher, 2, 4);
565 // SS.BBN.SS
566 input = spaces + wordChar +wordChar + nsm + spaces;
567 twoFindIndexes(input, matcher, 2, 5);
568 // SS.BN.SS
569 input = spaces + wordChar + nsm + spaces;
570 twoFindIndexes(input, matcher, 2, 4);
571 // SS.BNN.SS
572 input = spaces + wordChar + nsm + nsm + spaces;
573 twoFindIndexes(input, matcher, 2, 5);
574 // SSN.BB.SS
575 input = spaces + nsm + wordChar + wordChar + spaces;
576 twoFindIndexes(input, matcher, 3, 5);
577 // SS.BNB.SS
578 input = spaces + wordChar + nsm + wordChar + spaces;
579 twoFindIndexes(input, matcher, 2, 5);
580 // SSNNSS
581 input = spaces + nsm + nsm + spaces;
582 matcher.reset(input);
583 if (matcher.find())
584 failCount++;
585 // SSN.BBN.SS
586 input = spaces + nsm + wordChar + wordChar + nsm + spaces;
587 twoFindIndexes(input, matcher, 3, 6);
588
589 report("Unicode word boundary");
590 }
591
592 private static void twoFindIndexes(String input, Matcher matcher, int a,
593 int b) throws Exception
594 {
595 matcher.reset(input);
596 matcher.find();
597 if (matcher.start() != a)
598 failCount++;
599 matcher.find();
600 if (matcher.start() != b)
601 failCount++;
602 }
603
604 // This test is for 6284152
605 static void check(String regex, String input, String[] expected) {
606 List<String> result = new ArrayList<String>();
607 Pattern p = Pattern.compile(regex);
608 Matcher m = p.matcher(input);
609 while (m.find()) {
610 result.add(m.group());
611 }
612 if (!Arrays.asList(expected).equals(result))
613 failCount++;
614 }
615
616 private static void lookbehindTest() throws Exception {
617 //Positive
618 check("(?<=%.{0,5})foo\\d",
619 "%foo1\n%bar foo2\n%bar foo3\n%blahblah foo4\nfoo5",
620 new String[]{"foo1", "foo2", "foo3"});
621
622 //boundary at end of the lookbehind sub-regex should work consistently
623 //with the boundary just after the lookbehind sub-regex
624 check("(?<=.*\\b)foo", "abcd foo", new String[]{"foo"});
625 check("(?<=.*)\\bfoo", "abcd foo", new String[]{"foo"});
626 check("(?<!abc )\\bfoo", "abc foo", new String[0]);
627 check("(?<!abc \\b)foo", "abc foo", new String[0]);
628
629 //Negative
630 check("(?<!%.{0,5})foo\\d",
631 "%foo1\n%bar foo2\n%bar foo3\n%blahblah foo4\nfoo5",
632 new String[] {"foo4", "foo5"});
633
634 //Positive greedy
635 check("(?<=%b{1,4})foo", "%bbbbfoo", new String[] {"foo"});
636
637 //Positive reluctant
638 check("(?<=%b{1,4}?)foo", "%bbbbfoo", new String[] {"foo"});
639
640 //supplementary
641 check("(?<=%b{1,4})fo\ud800\udc00o", "%bbbbfo\ud800\udc00o",
642 new String[] {"fo\ud800\udc00o"});
643 check("(?<=%b{1,4}?)fo\ud800\udc00o", "%bbbbfo\ud800\udc00o",
644 new String[] {"fo\ud800\udc00o"});
645 check("(?<!%b{1,4})fo\ud800\udc00o", "%afo\ud800\udc00o",
646 new String[] {"fo\ud800\udc00o"});
647 check("(?<!%b{1,4}?)fo\ud800\udc00o", "%afo\ud800\udc00o",
648 new String[] {"fo\ud800\udc00o"});
649 report("Lookbehind");
650 }
651
652 // This test is for 4938995
653 // Check to see if weak region boundaries are transparent to
654 // lookahead and lookbehind constructs
655 private static void boundsTest() throws Exception {
656 String fullMessage = "catdogcat";
657 Pattern pattern = Pattern.compile("(?<=cat)dog(?=cat)");
658 Matcher matcher = pattern.matcher("catdogca");
659 matcher.useTransparentBounds(true);
660 if (matcher.find())
661 failCount++;
662 matcher.reset("atdogcat");
663 if (matcher.find())
664 failCount++;
665 matcher.reset(fullMessage);
666 if (!matcher.find())
667 failCount++;
668 matcher.reset(fullMessage);
669 matcher.region(0,9);
670 if (!matcher.find())
671 failCount++;
672 matcher.reset(fullMessage);
673 matcher.region(0,6);
674 if (!matcher.find())
675 failCount++;
676 matcher.reset(fullMessage);
677 matcher.region(3,6);
678 if (!matcher.find())
679 failCount++;
680 matcher.useTransparentBounds(false);
681 if (matcher.find())
682 failCount++;
683
684 // Negative lookahead/lookbehind
685 pattern = Pattern.compile("(?<!cat)dog(?!cat)");
686 matcher = pattern.matcher("dogcat");
687 matcher.useTransparentBounds(true);
688 matcher.region(0,3);
689 if (matcher.find())
690 failCount++;
691 matcher.reset("catdog");
692 matcher.region(3,6);
693 if (matcher.find())
694 failCount++;
695 matcher.useTransparentBounds(false);
696 matcher.reset("dogcat");
697 matcher.region(0,3);
698 if (!matcher.find())
699 failCount++;
700 matcher.reset("catdog");
701 matcher.region(3,6);
702 if (!matcher.find())
703 failCount++;
704
705 report("Region bounds transparency");
706 }
707
708 // This test is for 4945394
709 private static void findFromTest() throws Exception {
710 String message = "This is 40 $0 message.";
711 Pattern pat = Pattern.compile("\\$0");
712 Matcher match = pat.matcher(message);
713 if (!match.find())
714 failCount++;
715 if (match.find())
716 failCount++;
717 if (match.find())
718 failCount++;
719 report("Check for alternating find");
720 }
721
722 // This test is for 4872664 and 4892980
723 private static void negatedCharClassTest() throws Exception {
724 Pattern pattern = Pattern.compile("[^>]");
725 Matcher matcher = pattern.matcher("\u203A");
726 if (!matcher.matches())
727 failCount++;
728 pattern = Pattern.compile("[^fr]");
729 matcher = pattern.matcher("a");
730 if (!matcher.find())
731 failCount++;
732 matcher.reset("\u203A");
733 if (!matcher.find())
734 failCount++;
735 String s = "for";
736 String result[] = s.split("[^fr]");
737 if (!result[0].equals("f"))
738 failCount++;
739 if (!result[1].equals("r"))
740 failCount++;
741 s = "f\u203Ar";
742 result = s.split("[^fr]");
743 if (!result[0].equals("f"))
744 failCount++;
745 if (!result[1].equals("r"))
746 failCount++;
747
748 // Test adding to bits, subtracting a node, then adding to bits again
749 pattern = Pattern.compile("[^f\u203Ar]");
750 matcher = pattern.matcher("a");
751 if (!matcher.find())
752 failCount++;
753 matcher.reset("f");
754 if (matcher.find())
755 failCount++;
756 matcher.reset("\u203A");
757 if (matcher.find())
758 failCount++;
759 matcher.reset("r");
760 if (matcher.find())
761 failCount++;
762 matcher.reset("\u203B");
763 if (!matcher.find())
764 failCount++;
765
766 // Test subtracting a node, adding to bits, subtracting again
767 pattern = Pattern.compile("[^\u203Ar\u203B]");
768 matcher = pattern.matcher("a");
769 if (!matcher.find())
770 failCount++;
771 matcher.reset("\u203A");
772 if (matcher.find())
773 failCount++;
774 matcher.reset("r");
775 if (matcher.find())
776 failCount++;
777 matcher.reset("\u203B");
778 if (matcher.find())
779 failCount++;
780 matcher.reset("\u203C");
781 if (!matcher.find())
782 failCount++;
783
784 report("Negated Character Class");
785 }
786
787 // This test is for 4628291
788 private static void toStringTest() throws Exception {
789 Pattern pattern = Pattern.compile("b+");
790 if (pattern.toString() != "b+")
791 failCount++;
792 Matcher matcher = pattern.matcher("aaabbbccc");
793 String matcherString = matcher.toString(); // unspecified
794 matcher.find();
795 matcherString = matcher.toString(); // unspecified
796 matcher.region(0,3);
797 matcherString = matcher.toString(); // unspecified
798 matcher.reset();
799 matcherString = matcher.toString(); // unspecified
800 report("toString");
801 }
802
803 // This test is for 4808962
804 private static void literalPatternTest() throws Exception {
805 int flags = Pattern.LITERAL;
806
807 Pattern pattern = Pattern.compile("abc\\t$^", flags);
808 check(pattern, "abc\\t$^", true);
809
810 pattern = Pattern.compile(Pattern.quote("abc\\t$^"));
811 check(pattern, "abc\\t$^", true);
812
813 pattern = Pattern.compile("\\Qa^$bcabc\\E", flags);
814 check(pattern, "\\Qa^$bcabc\\E", true);
815 check(pattern, "a^$bcabc", false);
816
817 pattern = Pattern.compile("\\\\Q\\\\E");
818 check(pattern, "\\Q\\E", true);
819
820 pattern = Pattern.compile("\\Qabc\\Eefg\\\\Q\\\\Ehij");
821 check(pattern, "abcefg\\Q\\Ehij", true);
822
823 pattern = Pattern.compile("\\\\\\Q\\\\E");
824 check(pattern, "\\\\\\\\", true);
825
826 pattern = Pattern.compile(Pattern.quote("\\Qa^$bcabc\\E"));
827 check(pattern, "\\Qa^$bcabc\\E", true);
828 check(pattern, "a^$bcabc", false);
829
830 pattern = Pattern.compile(Pattern.quote("\\Qabc\\Edef"));
831 check(pattern, "\\Qabc\\Edef", true);
832 check(pattern, "abcdef", false);
833
834 pattern = Pattern.compile(Pattern.quote("abc\\Edef"));
835 check(pattern, "abc\\Edef", true);
836 check(pattern, "abcdef", false);
837
838 pattern = Pattern.compile(Pattern.quote("\\E"));
839 check(pattern, "\\E", true);
840
841 pattern = Pattern.compile("((((abc.+?:)", flags);
842 check(pattern, "((((abc.+?:)", true);
843
844 flags |= Pattern.MULTILINE;
845
846 pattern = Pattern.compile("^cat$", flags);
847 check(pattern, "abc^cat$def", true);
848 check(pattern, "cat", false);
849
850 flags |= Pattern.CASE_INSENSITIVE;
851
852 pattern = Pattern.compile("abcdef", flags);
853 check(pattern, "ABCDEF", true);
854 check(pattern, "AbCdEf", true);
855
856 flags |= Pattern.DOTALL;
857
858 pattern = Pattern.compile("a...b", flags);
859 check(pattern, "A...b", true);
860 check(pattern, "Axxxb", false);
861
862 flags |= Pattern.CANON_EQ;
863
864 Pattern p = Pattern.compile("testa\u030a", flags);
865 check(pattern, "testa\u030a", false);
866 check(pattern, "test\u00e5", false);
867
868 // Supplementary character test
869 flags = Pattern.LITERAL;
870
871 pattern = Pattern.compile(toSupplementaries("abc\\t$^"), flags);
872 check(pattern, toSupplementaries("abc\\t$^"), true);
873
874 pattern = Pattern.compile(Pattern.quote(toSupplementaries("abc\\t$^")));
875 check(pattern, toSupplementaries("abc\\t$^"), true);
876
877 pattern = Pattern.compile(toSupplementaries("\\Qa^$bcabc\\E"), flags);
878 check(pattern, toSupplementaries("\\Qa^$bcabc\\E"), true);
879 check(pattern, toSupplementaries("a^$bcabc"), false);
880
881 pattern = Pattern.compile(Pattern.quote(toSupplementaries("\\Qa^$bcabc\\E")));
882 check(pattern, toSupplementaries("\\Qa^$bcabc\\E"), true);
883 check(pattern, toSupplementaries("a^$bcabc"), false);
884
885 pattern = Pattern.compile(Pattern.quote(toSupplementaries("\\Qabc\\Edef")));
886 check(pattern, toSupplementaries("\\Qabc\\Edef"), true);
887 check(pattern, toSupplementaries("abcdef"), false);
888
889 pattern = Pattern.compile(Pattern.quote(toSupplementaries("abc\\Edef")));
890 check(pattern, toSupplementaries("abc\\Edef"), true);
891 check(pattern, toSupplementaries("abcdef"), false);
892
893 pattern = Pattern.compile(toSupplementaries("((((abc.+?:)"), flags);
894 check(pattern, toSupplementaries("((((abc.+?:)"), true);
895
896 flags |= Pattern.MULTILINE;
897
898 pattern = Pattern.compile(toSupplementaries("^cat$"), flags);
899 check(pattern, toSupplementaries("abc^cat$def"), true);
900 check(pattern, toSupplementaries("cat"), false);
901
902 flags |= Pattern.DOTALL;
903
904 // note: this is case-sensitive.
905 pattern = Pattern.compile(toSupplementaries("a...b"), flags);
906 check(pattern, toSupplementaries("a...b"), true);
907 check(pattern, toSupplementaries("axxxb"), false);
908
909 flags |= Pattern.CANON_EQ;
910
911 String t = toSupplementaries("test");
912 p = Pattern.compile(t + "a\u030a", flags);
913 check(pattern, t + "a\u030a", false);
914 check(pattern, t + "\u00e5", false);
915
916 report("Literal pattern");
917 }
918
919 // This test is for 4803179
920 // This test is also for 4808962, replacement parts
921 private static void literalReplacementTest() throws Exception {
922 int flags = Pattern.LITERAL;
923
924 Pattern pattern = Pattern.compile("abc", flags);
925 Matcher matcher = pattern.matcher("zzzabczzz");
926 String replaceTest = "$0";
927 String result = matcher.replaceAll(replaceTest);
928 if (!result.equals("zzzabczzz"))
929 failCount++;
930
931 matcher.reset();
932 String literalReplacement = matcher.quoteReplacement(replaceTest);
933 result = matcher.replaceAll(literalReplacement);
934 if (!result.equals("zzz$0zzz"))
935 failCount++;
936
937 matcher.reset();
938 replaceTest = "\\t$\\$";
939 literalReplacement = matcher.quoteReplacement(replaceTest);
940 result = matcher.replaceAll(literalReplacement);
941 if (!result.equals("zzz\\t$\\$zzz"))
942 failCount++;
943
944 // Supplementary character test
945 pattern = Pattern.compile(toSupplementaries("abc"), flags);
946 matcher = pattern.matcher(toSupplementaries("zzzabczzz"));
947 replaceTest = "$0";
948 result = matcher.replaceAll(replaceTest);
949 if (!result.equals(toSupplementaries("zzzabczzz")))
950 failCount++;
951
952 matcher.reset();
953 literalReplacement = matcher.quoteReplacement(replaceTest);
954 result = matcher.replaceAll(literalReplacement);
955 if (!result.equals(toSupplementaries("zzz$0zzz")))
956 failCount++;
957
958 matcher.reset();
959 replaceTest = "\\t$\\$";
960 literalReplacement = matcher.quoteReplacement(replaceTest);
961 result = matcher.replaceAll(literalReplacement);
962 if (!result.equals(toSupplementaries("zzz\\t$\\$zzz")))
963 failCount++;
964
965 // IAE should be thrown if backslash or '$' is the last character
966 // in replacement string
967 try {
968 "\uac00".replaceAll("\uac00", "$");
969 failCount++;
970 } catch (IllegalArgumentException iie) {
971 } catch (Exception e) {
972 failCount++;
973 }
974 try {
975 "\uac00".replaceAll("\uac00", "\\");
976 failCount++;
977 } catch (IllegalArgumentException iie) {
978 } catch (Exception e) {
979 failCount++;
980 }
981 report("Literal replacement");
982 }
983
984 // This test is for 4757029
985 private static void regionTest() throws Exception {
986 Pattern pattern = Pattern.compile("abc");
987 Matcher matcher = pattern.matcher("abcdefabc");
988
989 matcher.region(0,9);
990 if (!matcher.find())
991 failCount++;
992 if (!matcher.find())
993 failCount++;
994 matcher.region(0,3);
995 if (!matcher.find())
996 failCount++;
997 matcher.region(3,6);
998 if (matcher.find())
999 failCount++;
1000 matcher.region(0,2);
1001 if (matcher.find())
1002 failCount++;
1003
1004 expectRegionFail(matcher, 1, -1);
1005 expectRegionFail(matcher, -1, -1);
1006 expectRegionFail(matcher, -1, 1);
1007 expectRegionFail(matcher, 5, 3);
1008 expectRegionFail(matcher, 5, 12);
1009 expectRegionFail(matcher, 12, 12);
1010
1011 pattern = Pattern.compile("^abc$");
1012 matcher = pattern.matcher("zzzabczzz");
1013 matcher.region(0,9);
1014 if (matcher.find())
1015 failCount++;
1016 matcher.region(3,6);
1017 if (!matcher.find())
1018 failCount++;
1019 matcher.region(3,6);
1020 matcher.useAnchoringBounds(false);
1021 if (matcher.find())
1022 failCount++;
1023
1024 // Supplementary character test
1025 pattern = Pattern.compile(toSupplementaries("abc"));
1026 matcher = pattern.matcher(toSupplementaries("abcdefabc"));
1027 matcher.region(0,9*2);
1028 if (!matcher.find())
1029 failCount++;
1030 if (!matcher.find())
1031 failCount++;
1032 matcher.region(0,3*2);
1033 if (!matcher.find())
1034 failCount++;
1035 matcher.region(1,3*2);
1036 if (matcher.find())
1037 failCount++;
1038 matcher.region(3*2,6*2);
1039 if (matcher.find())
1040 failCount++;
1041 matcher.region(0,2*2);
1042 if (matcher.find())
1043 failCount++;
1044 matcher.region(0,2*2+1);
1045 if (matcher.find())
1046 failCount++;
1047
1048 expectRegionFail(matcher, 1*2, -1);
1049 expectRegionFail(matcher, -1, -1);
1050 expectRegionFail(matcher, -1, 1*2);
1051 expectRegionFail(matcher, 5*2, 3*2);
1052 expectRegionFail(matcher, 5*2, 12*2);
1053 expectRegionFail(matcher, 12*2, 12*2);
1054
1055 pattern = Pattern.compile(toSupplementaries("^abc$"));
1056 matcher = pattern.matcher(toSupplementaries("zzzabczzz"));
1057 matcher.region(0,9*2);
1058 if (matcher.find())
1059 failCount++;
1060 matcher.region(3*2,6*2);
1061 if (!matcher.find())
1062 failCount++;
1063 matcher.region(3*2+1,6*2);
1064 if (matcher.find())
1065 failCount++;
1066 matcher.region(3*2,6*2-1);
1067 if (matcher.find())
1068 failCount++;
1069 matcher.region(3*2,6*2);
1070 matcher.useAnchoringBounds(false);
1071 if (matcher.find())
1072 failCount++;
1073
1074 // JDK-8230829
1075 pattern = Pattern.compile("\\ud800\\udc61");
1076 matcher = pattern.matcher("\ud800\udc61");
1077 matcher.region(0, 1);
1078 if (matcher.find()) {
1079 failCount++;
1080 System.out.println("Matched a surrogate pair" +
1081 " that crosses border of region");
1082 }
1083 if (!matcher.hitEnd()) {
1084 failCount++;
1085 System.out.println("Expected to hit the end when" +
1086 " matching a surrogate pair crossing region");
1087 }
1088
1089 report("Regions");
1090 }
1091
1092 private static void expectRegionFail(Matcher matcher, int index1,
1093 int index2)
1094 {
1095 try {
1096 matcher.region(index1, index2);
1097 failCount++;
1098 } catch (IndexOutOfBoundsException ioobe) {
1099 // Correct result
1100 } catch (IllegalStateException ise) {
1101 // Correct result
1102 }
1103 }
1104
1105 // This test is for 4803197
1106 private static void escapedSegmentTest() throws Exception {
1107
1108 Pattern pattern = Pattern.compile("\\Qdir1\\dir2\\E");
1109 check(pattern, "dir1\\dir2", true);
1110
1111 pattern = Pattern.compile("\\Qdir1\\dir2\\\\E");
1112 check(pattern, "dir1\\dir2\\", true);
1113
1114 pattern = Pattern.compile("(\\Qdir1\\dir2\\\\E)");
1115 check(pattern, "dir1\\dir2\\", true);
1116
1117 // Supplementary character test
1118 pattern = Pattern.compile(toSupplementaries("\\Qdir1\\dir2\\E"));
1119 check(pattern, toSupplementaries("dir1\\dir2"), true);
1120
1121 pattern = Pattern.compile(toSupplementaries("\\Qdir1\\dir2")+"\\\\E");
1122 check(pattern, toSupplementaries("dir1\\dir2\\"), true);
1123
1124 pattern = Pattern.compile(toSupplementaries("(\\Qdir1\\dir2")+"\\\\E)");
1125 check(pattern, toSupplementaries("dir1\\dir2\\"), true);
1126
1127 report("Escaped segment");
1128 }
1129
1130 // This test is for 4792284
1131 private static void nonCaptureRepetitionTest() throws Exception {
1132 String input = "abcdefgh;";
1133
1134 String[] patterns = new String[] {
1135 "(?:\\w{4})+;",
1136 "(?:\\w{8})*;",
1137 "(?:\\w{2}){2,4};",
1138 "(?:\\w{4}){2,};", // only matches the
1139 ".*?(?:\\w{5})+;", // specified minimum
1140 ".*?(?:\\w{9})*;", // number of reps - OK
1141 "(?:\\w{4})+?;", // lazy repetition - OK
1142 "(?:\\w{4})++;", // possessive repetition - OK
1143 "(?:\\w{2,}?)+;", // non-deterministic - OK
1144 "(\\w{4})+;", // capturing group - OK
1145 };
1146
1147 for (int i = 0; i < patterns.length; i++) {
1148 // Check find()
1149 check(patterns[i], 0, input, input, true);
1150 // Check matches()
1151 Pattern p = Pattern.compile(patterns[i]);
1152 Matcher m = p.matcher(input);
1153
1154 if (m.matches()) {
1155 if (!m.group(0).equals(input))
1156 failCount++;
1157 } else {
1158 failCount++;
1159 }
1160 }
1161
1162 report("Non capturing repetition");
1163 }
1164
1165 // This test is for 6358731
1166 private static void notCapturedGroupCurlyMatchTest() throws Exception {
1167 Pattern pattern = Pattern.compile("(abc)+|(abcd)+");
1168 Matcher matcher = pattern.matcher("abcd");
1169 if (!matcher.matches() ||
1170 matcher.group(1) != null ||
1171 !matcher.group(2).equals("abcd")) {
1172 failCount++;
1173 }
1174 report("Not captured GroupCurly");
1175 }
1176
1177 // This test is for 4706545
1178 private static void javaCharClassTest() throws Exception {
1179 for (int i=0; i<1000; i++) {
1180 char c = (char)generator.nextInt();
1181 check("{javaLowerCase}", c, Character.isLowerCase(c));
1182 check("{javaUpperCase}", c, Character.isUpperCase(c));
1183 check("{javaUpperCase}+", c, Character.isUpperCase(c));
1184 check("{javaTitleCase}", c, Character.isTitleCase(c));
1185 check("{javaDigit}", c, Character.isDigit(c));
1186 check("{javaDefined}", c, Character.isDefined(c));
1187 check("{javaLetter}", c, Character.isLetter(c));
1188 check("{javaLetterOrDigit}", c, Character.isLetterOrDigit(c));
1189 check("{javaJavaIdentifierStart}", c,
1190 Character.isJavaIdentifierStart(c));
1191 check("{javaJavaIdentifierPart}", c,
1192 Character.isJavaIdentifierPart(c));
1193 check("{javaUnicodeIdentifierStart}", c,
1194 Character.isUnicodeIdentifierStart(c));
1195 check("{javaUnicodeIdentifierPart}", c,
1196 Character.isUnicodeIdentifierPart(c));
1197 check("{javaIdentifierIgnorable}", c,
1198 Character.isIdentifierIgnorable(c));
1199 check("{javaSpaceChar}", c, Character.isSpaceChar(c));
1200 check("{javaWhitespace}", c, Character.isWhitespace(c));
1201 check("{javaISOControl}", c, Character.isISOControl(c));
1202 check("{javaMirrored}", c, Character.isMirrored(c));
1203
1204 }
1205
1206 // Supplementary character test
1207 for (int i=0; i<1000; i++) {
1208 int c = generator.nextInt(Character.MAX_CODE_POINT
1209 - Character.MIN_SUPPLEMENTARY_CODE_POINT)
1210 + Character.MIN_SUPPLEMENTARY_CODE_POINT;
1211 check("{javaLowerCase}", c, Character.isLowerCase(c));
1212 check("{javaUpperCase}", c, Character.isUpperCase(c));
1213 check("{javaUpperCase}+", c, Character.isUpperCase(c));
1214 check("{javaTitleCase}", c, Character.isTitleCase(c));
1215 check("{javaDigit}", c, Character.isDigit(c));
1216 check("{javaDefined}", c, Character.isDefined(c));
1217 check("{javaLetter}", c, Character.isLetter(c));
1218 check("{javaLetterOrDigit}", c, Character.isLetterOrDigit(c));
1219 check("{javaJavaIdentifierStart}", c,
1220 Character.isJavaIdentifierStart(c));
1221 check("{javaJavaIdentifierPart}", c,
1222 Character.isJavaIdentifierPart(c));
1223 check("{javaUnicodeIdentifierStart}", c,
1224 Character.isUnicodeIdentifierStart(c));
1225 check("{javaUnicodeIdentifierPart}", c,
1226 Character.isUnicodeIdentifierPart(c));
1227 check("{javaIdentifierIgnorable}", c,
1228 Character.isIdentifierIgnorable(c));
1229 check("{javaSpaceChar}", c, Character.isSpaceChar(c));
1230 check("{javaWhitespace}", c, Character.isWhitespace(c));
1231 check("{javaISOControl}", c, Character.isISOControl(c));
1232 check("{javaMirrored}", c, Character.isMirrored(c));
1233 }
1234
1235 report("Java character classes");
1236 }
1237
1238 // This test is for 4523620
1239 /*
1240 private static void numOccurrencesTest() throws Exception {
1241 Pattern pattern = Pattern.compile("aaa");
1242
1243 if (pattern.numOccurrences("aaaaaa", false) != 2)
1244 failCount++;
1245 if (pattern.numOccurrences("aaaaaa", true) != 4)
1246 failCount++;
1247
1248 pattern = Pattern.compile("^");
1249 if (pattern.numOccurrences("aaaaaa", false) != 1)
1250 failCount++;
1251 if (pattern.numOccurrences("aaaaaa", true) != 1)
1252 failCount++;
1253
1254 report("Number of Occurrences");
1255 }
1256 */
1257
1258 // This test is for 4776374
1259 private static void caretBetweenTerminatorsTest() throws Exception {
1260 int flags1 = Pattern.DOTALL;
1261 int flags2 = Pattern.DOTALL | Pattern.UNIX_LINES;
1262 int flags3 = Pattern.DOTALL | Pattern.UNIX_LINES | Pattern.MULTILINE;
1263 int flags4 = Pattern.DOTALL | Pattern.MULTILINE;
1264
1265 check("^....", flags1, "test\ntest", "test", true);
1266 check(".....^", flags1, "test\ntest", "test", false);
1267 check(".....^", flags1, "test\n", "test", false);
1268 check("....^", flags1, "test\r\n", "test", false);
1269
1270 check("^....", flags2, "test\ntest", "test", true);
1271 check("....^", flags2, "test\ntest", "test", false);
1272 check(".....^", flags2, "test\n", "test", false);
1273 check("....^", flags2, "test\r\n", "test", false);
1274
1275 check("^....", flags3, "test\ntest", "test", true);
1276 check(".....^", flags3, "test\ntest", "test\n", true);
1277 check(".....^", flags3, "test\u0085test", "test\u0085", false);
1278 check(".....^", flags3, "test\n", "test", false);
1279 check(".....^", flags3, "test\r\n", "test", false);
1280 check("......^", flags3, "test\r\ntest", "test\r\n", true);
1281
1282 check("^....", flags4, "test\ntest", "test", true);
1283 check(".....^", flags3, "test\ntest", "test\n", true);
1284 check(".....^", flags4, "test\u0085test", "test\u0085", true);
1285 check(".....^", flags4, "test\n", "test\n", false);
1286 check(".....^", flags4, "test\r\n", "test\r", false);
1287
1288 // Supplementary character test
1289 String t = toSupplementaries("test");
1290 check("^....", flags1, t+"\n"+t, t, true);
1291 check(".....^", flags1, t+"\n"+t, t, false);
1292 check(".....^", flags1, t+"\n", t, false);
1293 check("....^", flags1, t+"\r\n", t, false);
1294
1295 check("^....", flags2, t+"\n"+t, t, true);
1296 check("....^", flags2, t+"\n"+t, t, false);
1297 check(".....^", flags2, t+"\n", t, false);
1298 check("....^", flags2, t+"\r\n", t, false);
1299
1300 check("^....", flags3, t+"\n"+t, t, true);
1301 check(".....^", flags3, t+"\n"+t, t+"\n", true);
1302 check(".....^", flags3, t+"\u0085"+t, t+"\u0085", false);
1303 check(".....^", flags3, t+"\n", t, false);
1304 check(".....^", flags3, t+"\r\n", t, false);
1305 check("......^", flags3, t+"\r\n"+t, t+"\r\n", true);
1306
1307 check("^....", flags4, t+"\n"+t, t, true);
1308 check(".....^", flags3, t+"\n"+t, t+"\n", true);
1309 check(".....^", flags4, t+"\u0085"+t, t+"\u0085", true);
1310 check(".....^", flags4, t+"\n", t+"\n", false);
1311 check(".....^", flags4, t+"\r\n", t+"\r", false);
1312
1313 report("Caret between terminators");
1314 }
1315
1316 // This test is for 4727935
1317 private static void dollarAtEndTest() throws Exception {
1318 int flags1 = Pattern.DOTALL;
1319 int flags2 = Pattern.DOTALL | Pattern.UNIX_LINES;
1320 int flags3 = Pattern.DOTALL | Pattern.MULTILINE;
1321
1322 check("....$", flags1, "test\n", "test", true);
1323 check("....$", flags1, "test\r\n", "test", true);
1324 check(".....$", flags1, "test\n", "test\n", true);
1325 check(".....$", flags1, "test\u0085", "test\u0085", true);
1326 check("....$", flags1, "test\u0085", "test", true);
1327
1328 check("....$", flags2, "test\n", "test", true);
1329 check(".....$", flags2, "test\n", "test\n", true);
1330 check(".....$", flags2, "test\u0085", "test\u0085", true);
1331 check("....$", flags2, "test\u0085", "est\u0085", true);
1332
1333 check("....$.blah", flags3, "test\nblah", "test\nblah", true);
1334 check(".....$.blah", flags3, "test\n\nblah", "test\n\nblah", true);
1335 check("....$blah", flags3, "test\nblah", "!!!!", false);
1336 check(".....$blah", flags3, "test\nblah", "!!!!", false);
1337
1338 // Supplementary character test
1339 String t = toSupplementaries("test");
1340 String b = toSupplementaries("blah");
1341 check("....$", flags1, t+"\n", t, true);
1342 check("....$", flags1, t+"\r\n", t, true);
1343 check(".....$", flags1, t+"\n", t+"\n", true);
1344 check(".....$", flags1, t+"\u0085", t+"\u0085", true);
1345 check("....$", flags1, t+"\u0085", t, true);
1346
1347 check("....$", flags2, t+"\n", t, true);
1348 check(".....$", flags2, t+"\n", t+"\n", true);
1349 check(".....$", flags2, t+"\u0085", t+"\u0085", true);
1350 check("....$", flags2, t+"\u0085", toSupplementaries("est\u0085"), true);
1351
1352 check("....$."+b, flags3, t+"\n"+b, t+"\n"+b, true);
1353 check(".....$."+b, flags3, t+"\n\n"+b, t+"\n\n"+b, true);
1354 check("....$"+b, flags3, t+"\n"+b, "!!!!", false);
1355 check(".....$"+b, flags3, t+"\n"+b, "!!!!", false);
1356
1357 report("Dollar at End");
1358 }
1359
1360 // This test is for 4711773
1361 private static void multilineDollarTest() throws Exception {
1362 Pattern findCR = Pattern.compile("$", Pattern.MULTILINE);
1363 Matcher matcher = findCR.matcher("first bit\nsecond bit");
1364 matcher.find();
1365 if (matcher.start(0) != 9)
1366 failCount++;
1367 matcher.find();
1368 if (matcher.start(0) != 20)
1369 failCount++;
1370
1371 // Supplementary character test
1372 matcher = findCR.matcher(toSupplementaries("first bit\n second bit")); // double BMP chars
1373 matcher.find();
1374 if (matcher.start(0) != 9*2)
1375 failCount++;
1376 matcher.find();
1377 if (matcher.start(0) != 20*2)
1378 failCount++;
1379
1380 report("Multiline Dollar");
1381 }
1382
1383 private static void reluctantRepetitionTest() throws Exception {
1384 Pattern p = Pattern.compile("1(\\s\\S+?){1,3}?[\\s,]2");
1385 check(p, "1 word word word 2", true);
1386 check(p, "1 wor wo w 2", true);
1387 check(p, "1 word word 2", true);
1388 check(p, "1 word 2", true);
1389 check(p, "1 wo w w 2", true);
1390 check(p, "1 wo w 2", true);
1391 check(p, "1 wor w 2", true);
1392
1393 p = Pattern.compile("([a-z])+?c");
1394 Matcher m = p.matcher("ababcdefdec");
1395 check(m, "ababc");
1396
1397 // Supplementary character test
1398 p = Pattern.compile(toSupplementaries("([a-z])+?c"));
1399 m = p.matcher(toSupplementaries("ababcdefdec"));
1400 check(m, toSupplementaries("ababc"));
1401
1402 report("Reluctant Repetition");
1403 }
1404
1405 private static Pattern serializedPattern(Pattern p) throws Exception {
1406 ByteArrayOutputStream baos = new ByteArrayOutputStream();
1407 ObjectOutputStream oos = new ObjectOutputStream(baos);
1408 oos.writeObject(p);
1409 oos.close();
1410 try (ObjectInputStream ois = new ObjectInputStream(
1411 new ByteArrayInputStream(baos.toByteArray()))) {
1412 return (Pattern)ois.readObject();
1413 }
1414 }
1415
1416 private static void serializeTest() throws Exception {
1417 String patternStr = "(b)";
1418 String matchStr = "b";
1419 Pattern pattern = Pattern.compile(patternStr);
1420 Pattern serializedPattern = serializedPattern(pattern);
1421 Matcher matcher = serializedPattern.matcher(matchStr);
1422 if (!matcher.matches())
1423 failCount++;
1424 if (matcher.groupCount() != 1)
1425 failCount++;
1426
1427 pattern = Pattern.compile("a(?-i)b", Pattern.CASE_INSENSITIVE);
1428 serializedPattern = serializedPattern(pattern);
1429 if (!serializedPattern.matcher("Ab").matches())
1430 failCount++;
1431 if (serializedPattern.matcher("AB").matches())
1432 failCount++;
1433
1434 report("Serialization");
1435 }
1436
1437 private static void gTest() {
1438 Pattern pattern = Pattern.compile("\\G\\w");
1439 Matcher matcher = pattern.matcher("abc#x#x");
1440 matcher.find();
1441 matcher.find();
1442 matcher.find();
1443 if (matcher.find())
1444 failCount++;
1445
1446 pattern = Pattern.compile("\\GA*");
1447 matcher = pattern.matcher("1A2AA3");
1448 matcher.find();
1449 if (matcher.find())
1450 failCount++;
1451
1452 pattern = Pattern.compile("\\GA*");
1453 matcher = pattern.matcher("1A2AA3");
1454 if (!matcher.find(1))
1455 failCount++;
1456 matcher.find();
1457 if (matcher.find())
1458 failCount++;
1459
1460 report("\\G");
1461 }
1462
1463 private static void zTest() {
1464 Pattern pattern = Pattern.compile("foo\\Z");
1465 // Positives
1466 check(pattern, "foo\u0085", true);
1467 check(pattern, "foo\u2028", true);
1468 check(pattern, "foo\u2029", true);
1469 check(pattern, "foo\n", true);
1470 check(pattern, "foo\r", true);
1471 check(pattern, "foo\r\n", true);
1472 // Negatives
1473 check(pattern, "fooo", false);
1474 check(pattern, "foo\n\r", false);
1475
1476 pattern = Pattern.compile("foo\\Z", Pattern.UNIX_LINES);
1477 // Positives
1478 check(pattern, "foo", true);
1479 check(pattern, "foo\n", true);
1480 // Negatives
1481 check(pattern, "foo\r", false);
1482 check(pattern, "foo\u0085", false);
1483 check(pattern, "foo\u2028", false);
1484 check(pattern, "foo\u2029", false);
1485
1486 report("\\Z");
1487 }
1488
1489 private static void replaceFirstTest() {
1490 Pattern pattern = Pattern.compile("(ab)(c*)");
1491 Matcher matcher = pattern.matcher("abccczzzabcczzzabccc");
1492 if (!matcher.replaceFirst("test").equals("testzzzabcczzzabccc"))
1493 failCount++;
1494
1495 matcher.reset("zzzabccczzzabcczzzabccczzz");
1496 if (!matcher.replaceFirst("test").equals("zzztestzzzabcczzzabccczzz"))
1497 failCount++;
1498
1499 matcher.reset("zzzabccczzzabcczzzabccczzz");
1500 String result = matcher.replaceFirst("$1");
1501 if (!result.equals("zzzabzzzabcczzzabccczzz"))
1502 failCount++;
1503
1504 matcher.reset("zzzabccczzzabcczzzabccczzz");
1505 result = matcher.replaceFirst("$2");
1506 if (!result.equals("zzzccczzzabcczzzabccczzz"))
1507 failCount++;
1508
1509 pattern = Pattern.compile("a*");
1510 matcher = pattern.matcher("aaaaaaaaaa");
1511 if (!matcher.replaceFirst("test").equals("test"))
1512 failCount++;
1513
1514 pattern = Pattern.compile("a+");
1515 matcher = pattern.matcher("zzzaaaaaaaaaa");
1516 if (!matcher.replaceFirst("test").equals("zzztest"))
1517 failCount++;
1518
1519 // Supplementary character test
1520 pattern = Pattern.compile(toSupplementaries("(ab)(c*)"));
1521 matcher = pattern.matcher(toSupplementaries("abccczzzabcczzzabccc"));
1522 if (!matcher.replaceFirst(toSupplementaries("test"))
1523 .equals(toSupplementaries("testzzzabcczzzabccc")))
1524 failCount++;
1525
1526 matcher.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz"));
1527 if (!matcher.replaceFirst(toSupplementaries("test")).
1528 equals(toSupplementaries("zzztestzzzabcczzzabccczzz")))
1529 failCount++;
1530
1531 matcher.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz"));
1532 result = matcher.replaceFirst("$1");
1533 if (!result.equals(toSupplementaries("zzzabzzzabcczzzabccczzz")))
1534 failCount++;
1535
1536 matcher.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz"));
1537 result = matcher.replaceFirst("$2");
1538 if (!result.equals(toSupplementaries("zzzccczzzabcczzzabccczzz")))
1539 failCount++;
1540
1541 pattern = Pattern.compile(toSupplementaries("a*"));
1542 matcher = pattern.matcher(toSupplementaries("aaaaaaaaaa"));
1543 if (!matcher.replaceFirst(toSupplementaries("test")).equals(toSupplementaries("test")))
1544 failCount++;
1545
1546 pattern = Pattern.compile(toSupplementaries("a+"));
1547 matcher = pattern.matcher(toSupplementaries("zzzaaaaaaaaaa"));
1548 if (!matcher.replaceFirst(toSupplementaries("test")).equals(toSupplementaries("zzztest")))
1549 failCount++;
1550
1551 report("Replace First");
1552 }
1553
1554 private static void unixLinesTest() {
1555 Pattern pattern = Pattern.compile(".*");
1556 Matcher matcher = pattern.matcher("aa\u2028blah");
1557 matcher.find();
1558 if (!matcher.group(0).equals("aa"))
1559 failCount++;
1560
1561 pattern = Pattern.compile(".*", Pattern.UNIX_LINES);
1562 matcher = pattern.matcher("aa\u2028blah");
1563 matcher.find();
1564 if (!matcher.group(0).equals("aa\u2028blah"))
1565 failCount++;
1566
1567 pattern = Pattern.compile("[az]$",
1568 Pattern.MULTILINE | Pattern.UNIX_LINES);
1569 matcher = pattern.matcher("aa\u2028zz");
1570 check(matcher, "a\u2028", false);
1571
1572 // Supplementary character test
1573 pattern = Pattern.compile(".*");
1574 matcher = pattern.matcher(toSupplementaries("aa\u2028blah"));
1575 matcher.find();
1576 if (!matcher.group(0).equals(toSupplementaries("aa")))
1577 failCount++;
1578
1579 pattern = Pattern.compile(".*", Pattern.UNIX_LINES);
1580 matcher = pattern.matcher(toSupplementaries("aa\u2028blah"));
1581 matcher.find();
1582 if (!matcher.group(0).equals(toSupplementaries("aa\u2028blah")))
1583 failCount++;
1584
1585 pattern = Pattern.compile(toSupplementaries("[az]$"),
1586 Pattern.MULTILINE | Pattern.UNIX_LINES);
1587 matcher = pattern.matcher(toSupplementaries("aa\u2028zz"));
1588 check(matcher, toSupplementaries("a\u2028"), false);
1589
1590 report("Unix Lines");
1591 }
1592
1593 private static void commentsTest() {
1594 int flags = Pattern.COMMENTS;
1595
1596 Pattern pattern = Pattern.compile("aa \\# aa", flags);
1597 Matcher matcher = pattern.matcher("aa#aa");
1598 if (!matcher.matches())
1599 failCount++;
1600
1601 pattern = Pattern.compile("aa # blah", flags);
1602 matcher = pattern.matcher("aa");
1603 if (!matcher.matches())
1604 failCount++;
1605
1606 pattern = Pattern.compile("aa blah", flags);
1607 matcher = pattern.matcher("aablah");
1608 if (!matcher.matches())
1609 failCount++;
1610
1611 pattern = Pattern.compile("aa # blah blech ", flags);
1612 matcher = pattern.matcher("aa");
1613 if (!matcher.matches())
1614 failCount++;
1615
1616 pattern = Pattern.compile("aa # blah\n ", flags);
1617 matcher = pattern.matcher("aa");
1618 if (!matcher.matches())
1619 failCount++;
1620
1621 pattern = Pattern.compile("aa # blah\nbc # blech", flags);
1622 matcher = pattern.matcher("aabc");
1623 if (!matcher.matches())
1624 failCount++;
1625
1626 pattern = Pattern.compile("aa # blah\nbc# blech", flags);
1627 matcher = pattern.matcher("aabc");
1628 if (!matcher.matches())
1629 failCount++;
1630
1631 pattern = Pattern.compile("aa # blah\nbc\\# blech", flags);
1632 matcher = pattern.matcher("aabc#blech");
1633 if (!matcher.matches())
1634 failCount++;
1635
1636 // Supplementary character test
1637 pattern = Pattern.compile(toSupplementaries("aa \\# aa"), flags);
1638 matcher = pattern.matcher(toSupplementaries("aa#aa"));
1639 if (!matcher.matches())
1640 failCount++;
1641
1642 pattern = Pattern.compile(toSupplementaries("aa # blah"), flags);
1643 matcher = pattern.matcher(toSupplementaries("aa"));
1644 if (!matcher.matches())
1645 failCount++;
1646
1647 pattern = Pattern.compile(toSupplementaries("aa blah"), flags);
1648 matcher = pattern.matcher(toSupplementaries("aablah"));
1649 if (!matcher.matches())
1650 failCount++;
1651
1652 pattern = Pattern.compile(toSupplementaries("aa # blah blech "), flags);
1653 matcher = pattern.matcher(toSupplementaries("aa"));
1654 if (!matcher.matches())
1655 failCount++;
1656
1657 pattern = Pattern.compile(toSupplementaries("aa # blah\n "), flags);
1658 matcher = pattern.matcher(toSupplementaries("aa"));
1659 if (!matcher.matches())
1660 failCount++;
1661
1662 pattern = Pattern.compile(toSupplementaries("aa # blah\nbc # blech"), flags);
1663 matcher = pattern.matcher(toSupplementaries("aabc"));
1664 if (!matcher.matches())
1665 failCount++;
1666
1667 pattern = Pattern.compile(toSupplementaries("aa # blah\nbc# blech"), flags);
1668 matcher = pattern.matcher(toSupplementaries("aabc"));
1669 if (!matcher.matches())
1670 failCount++;
1671
1672 pattern = Pattern.compile(toSupplementaries("aa # blah\nbc\\# blech"), flags);
1673 matcher = pattern.matcher(toSupplementaries("aabc#blech"));
1674 if (!matcher.matches())
1675 failCount++;
1676
1677 report("Comments");
1678 }
1679
1680 private static void caseFoldingTest() { // bug 4504687
1681 int flags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE;
1682 Pattern pattern = Pattern.compile("aa", flags);
1683 Matcher matcher = pattern.matcher("ab");
1684 if (matcher.matches())
1685 failCount++;
1686
1687 pattern = Pattern.compile("aA", flags);
1688 matcher = pattern.matcher("ab");
1689 if (matcher.matches())
1690 failCount++;
1691
1692 pattern = Pattern.compile("aa", flags);
1693 matcher = pattern.matcher("aB");
1694 if (matcher.matches())
1695 failCount++;
1696 matcher = pattern.matcher("Ab");
1697 if (matcher.matches())
1698 failCount++;
1699
1700 // ASCII "a"
1701 // Latin-1 Supplement "a" + grave
1702 // Cyrillic "a"
1703 String[] patterns = new String[] {
1704 //single
1705 "a", "\u00e0", "\u0430",
1706 //slice
1707 "ab", "\u00e0\u00e1", "\u0430\u0431",
1708 //class single
1709 "[a]", "[\u00e0]", "[\u0430]",
1710 //class range
1711 "[a-b]", "[\u00e0-\u00e5]", "[\u0430-\u0431]",
1712 //back reference
1713 "(a)\\1", "(\u00e0)\\1", "(\u0430)\\1"
1714 };
1715
1716 String[] texts = new String[] {
1717 "A", "\u00c0", "\u0410",
1718 "AB", "\u00c0\u00c1", "\u0410\u0411",
1719 "A", "\u00c0", "\u0410",
1720 "B", "\u00c2", "\u0411",
1721 "aA", "\u00e0\u00c0", "\u0430\u0410"
1722 };
1723
1724 boolean[] expected = new boolean[] {
1725 true, false, false,
1726 true, false, false,
1727 true, false, false,
1728 true, false, false,
1729 true, false, false
1730 };
1731
1732 flags = Pattern.CASE_INSENSITIVE;
1733 for (int i = 0; i < patterns.length; i++) {
1734 pattern = Pattern.compile(patterns[i], flags);
1735 matcher = pattern.matcher(texts[i]);
1736 if (matcher.matches() != expected[i]) {
1737 System.out.println("<1> Failed at " + i);
1738 failCount++;
1739 }
1740 }
1741
1742 flags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE;
1743 for (int i = 0; i < patterns.length; i++) {
1744 pattern = Pattern.compile(patterns[i], flags);
1745 matcher = pattern.matcher(texts[i]);
1746 if (!matcher.matches()) {
1747 System.out.println("<2> Failed at " + i);
1748 failCount++;
1749 }
1750 }
1751 // flag unicode_case alone should do nothing
1752 flags = Pattern.UNICODE_CASE;
1753 for (int i = 0; i < patterns.length; i++) {
1754 pattern = Pattern.compile(patterns[i], flags);
1755 matcher = pattern.matcher(texts[i]);
1756 if (matcher.matches()) {
1757 System.out.println("<3> Failed at " + i);
1758 failCount++;
1759 }
1760 }
1761
1762 // Special cases: i, I, u+0131 and u+0130
1763 flags = Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE;
1764 pattern = Pattern.compile("[h-j]+", flags);
1765 if (!pattern.matcher("\u0131\u0130").matches())
1766 failCount++;
1767 report("Case Folding");
1768 }
1769
1770 private static void appendTest() {
1771 Pattern pattern = Pattern.compile("(ab)(cd)");
1772 Matcher matcher = pattern.matcher("abcd");
1773 String result = matcher.replaceAll("$2$1");
1774 if (!result.equals("cdab"))
1775 failCount++;
1776
1777 String s1 = "Swap all: first = 123, second = 456";
1778 String s2 = "Swap one: first = 123, second = 456";
1779 String r = "$3$2$1";
1780 pattern = Pattern.compile("([a-z]+)( *= *)([0-9]+)");
1781 matcher = pattern.matcher(s1);
1782
1783 result = matcher.replaceAll(r);
1784 if (!result.equals("Swap all: 123 = first, 456 = second"))
1785 failCount++;
1786
1787 matcher = pattern.matcher(s2);
1788
1789 if (matcher.find()) {
1790 StringBuffer sb = new StringBuffer();
1791 matcher.appendReplacement(sb, r);
1792 matcher.appendTail(sb);
1793 result = sb.toString();
1794 if (!result.equals("Swap one: 123 = first, second = 456"))
1795 failCount++;
1796 }
1797
1798 // Supplementary character test
1799 pattern = Pattern.compile(toSupplementaries("(ab)(cd)"));
1800 matcher = pattern.matcher(toSupplementaries("abcd"));
1801 result = matcher.replaceAll("$2$1");
1802 if (!result.equals(toSupplementaries("cdab")))
1803 failCount++;
1804
1805 s1 = toSupplementaries("Swap all: first = 123, second = 456");
1806 s2 = toSupplementaries("Swap one: first = 123, second = 456");
1807 r = toSupplementaries("$3$2$1");
1808 pattern = Pattern.compile(toSupplementaries("([a-z]+)( *= *)([0-9]+)"));
1809 matcher = pattern.matcher(s1);
1810
1811 result = matcher.replaceAll(r);
1812 if (!result.equals(toSupplementaries("Swap all: 123 = first, 456 = second")))
1813 failCount++;
1814
1815 matcher = pattern.matcher(s2);
1816
1817 if (matcher.find()) {
1818 StringBuffer sb = new StringBuffer();
1819 matcher.appendReplacement(sb, r);
1820 matcher.appendTail(sb);
1821 result = sb.toString();
1822 if (!result.equals(toSupplementaries("Swap one: 123 = first, second = 456")))
1823 failCount++;
1824 }
1825 report("Append");
1826 }
1827
1828 private static void splitTest() {
1829 Pattern pattern = Pattern.compile(":");
1830 String[] result = pattern.split("foo:and:boo", 2);
1831 if (!result[0].equals("foo"))
1832 failCount++;
1833 if (!result[1].equals("and:boo"))
1834 failCount++;
1835 // Supplementary character test
1836 Pattern patternX = Pattern.compile(toSupplementaries("X"));
1837 result = patternX.split(toSupplementaries("fooXandXboo"), 2);
1838 if (!result[0].equals(toSupplementaries("foo")))
1839 failCount++;
1840 if (!result[1].equals(toSupplementaries("andXboo")))
1841 failCount++;
1842
1843 CharBuffer cb = CharBuffer.allocate(100);
1844 cb.put("foo:and:boo");
1845 cb.flip();
1846 result = pattern.split(cb);
1847 if (!result[0].equals("foo"))
1848 failCount++;
1849 if (!result[1].equals("and"))
1850 failCount++;
1851 if (!result[2].equals("boo"))
1852 failCount++;
1853
1854 // Supplementary character test
1855 CharBuffer cbs = CharBuffer.allocate(100);
1856 cbs.put(toSupplementaries("fooXandXboo"));
1857 cbs.flip();
1858 result = patternX.split(cbs);
1859 if (!result[0].equals(toSupplementaries("foo")))
1860 failCount++;
1861 if (!result[1].equals(toSupplementaries("and")))
1862 failCount++;
1863 if (!result[2].equals(toSupplementaries("boo")))
1864 failCount++;
1865
1866 String source = "0123456789";
1867 for (int limit=-2; limit<3; limit++) {
1868 for (int x=0; x<10; x++) {
1869 result = source.split(Integer.toString(x), limit);
1870 int expectedLength = limit < 1 ? 2 : limit;
1871
1872 if ((limit == 0) && (x == 9)) {
1873 // expected dropping of ""
1874 if (result.length != 1)
1875 failCount++;
1876 if (!result[0].equals("012345678")) {
1877 failCount++;
1878 }
1879 } else {
1880 if (result.length != expectedLength) {
1881 failCount++;
1882 }
1883 if (!result[0].equals(source.substring(0,x))) {
1884 if (limit != 1) {
1885 failCount++;
1886 } else {
1887 if (!result[0].equals(source.substring(0,10))) {
1888 failCount++;
1889 }
1890 }
1891 }
1892 if (expectedLength > 1) { // Check segment 2
1893 if (!result[1].equals(source.substring(x+1,10)))
1894 failCount++;
1895 }
1896 }
1897 }
1898 }
1899 // Check the case for no match found
1900 for (int limit=-2; limit<3; limit++) {
1901 result = source.split("e", limit);
1902 if (result.length != 1)
1903 failCount++;
1904 if (!result[0].equals(source))
1905 failCount++;
1906 }
1907 // Check the case for limit == 0, source = "";
1908 // split() now returns 0-length for empty source "" see #6559590
1909 source = "";
1910 result = source.split("e", 0);
1911 if (result.length != 1)
1912 failCount++;
1913 if (!result[0].equals(source))
1914 failCount++;
1915
1916 // Check both split() and splitAsStraem(), especially for zero-lenth
1917 // input and zero-lenth match cases
1918 String[][] input = new String[][] {
1919 { " ", "Abc Efg Hij" }, // normal non-zero-match
1920 { " ", " Abc Efg Hij" }, // leading empty str for non-zero-match
1921 { " ", "Abc Efg Hij" }, // non-zero-match in the middle
1922 { "(?=\\p{Lu})", "AbcEfgHij" }, // no leading empty str for zero-match
1923 { "(?=\\p{Lu})", "AbcEfg" },
1924 { "(?=\\p{Lu})", "Abc" },
1925 { " ", "" }, // zero-length input
1926 { ".*", "" },
1927
1928 // some tests from PatternStreamTest.java
1929 { "4", "awgqwefg1fefw4vssv1vvv1" },
1930 { "\u00a3a", "afbfq\u00a3abgwgb\u00a3awngnwggw\u00a3a\u00a3ahjrnhneerh" },
1931 { "1", "awgqwefg1fefw4vssv1vvv1" },
1932 { "1", "a\u4ebafg1fefw\u4eba4\u9f9cvssv\u9f9c1v\u672c\u672cvv" },
1933 { "\u56da", "1\u56da23\u56da456\u56da7890" },
1934 { "\u56da", "1\u56da23\u9f9c\u672c\u672c\u56da456\u56da\u9f9c\u672c7890" },
1935 { "\u56da", "" },
1936 { "[ \t,:.]","This is,testing: with\tdifferent separators." }, //multiple septs
1937 { "o", "boo:and:foo" },
1938 { "o", "booooo:and:fooooo" },
1939 { "o", "fooooo:" },
1940 };
1941
1942 String[][] expected = new String[][] {
1943 { "Abc", "Efg", "Hij" },
1944 { "", "Abc", "Efg", "Hij" },
1945 { "Abc", "", "Efg", "Hij" },
1946 { "Abc", "Efg", "Hij" },
1947 { "Abc", "Efg" },
1948 { "Abc" },
1949 { "" },
1950 { "" },
1951
1952 { "awgqwefg1fefw", "vssv1vvv1" },
1953 { "afbfq", "bgwgb", "wngnwggw", "", "hjrnhneerh" },
1954 { "awgqwefg", "fefw4vssv", "vvv" },
1955 { "a\u4ebafg", "fefw\u4eba4\u9f9cvssv\u9f9c", "v\u672c\u672cvv" },
1956 { "1", "23", "456", "7890" },
1957 { "1", "23\u9f9c\u672c\u672c", "456", "\u9f9c\u672c7890" },
1958 { "" },
1959 { "This", "is", "testing", "", "with", "different", "separators" },
1960 { "b", "", ":and:f" },
1961 { "b", "", "", "", "", ":and:f" },
1962 { "f", "", "", "", "", ":" },
1963 };
1964 for (int i = 0; i < input.length; i++) {
1965 pattern = Pattern.compile(input[i][0]);
1966 if (!Arrays.equals(pattern.split(input[i][1]), expected[i])) {
1967 failCount++;
1968 }
1969 if (input[i][1].length() > 0 && // splitAsStream() return empty resulting
1970 // array for zero-length input for now
1971 !Arrays.equals(pattern.splitAsStream(input[i][1]).toArray(),
1972 expected[i])) {
1973 failCount++;
1974 }
1975 }
1976 report("Split");
1977 }
1978
1979 private static void negationTest() {
1980 Pattern pattern = Pattern.compile("[\\[@^]+");
1981 Matcher matcher = pattern.matcher("@@@@[[[[^^^^");
1982 if (!matcher.find())
1983 failCount++;
1984 if (!matcher.group(0).equals("@@@@[[[[^^^^"))
1985 failCount++;
1986 pattern = Pattern.compile("[@\\[^]+");
1987 matcher = pattern.matcher("@@@@[[[[^^^^");
1988 if (!matcher.find())
1989 failCount++;
1990 if (!matcher.group(0).equals("@@@@[[[[^^^^"))
1991 failCount++;
1992 pattern = Pattern.compile("[@\\[^@]+");
1993 matcher = pattern.matcher("@@@@[[[[^^^^");
1994 if (!matcher.find())
1995 failCount++;
1996 if (!matcher.group(0).equals("@@@@[[[[^^^^"))
1997 failCount++;
1998
1999 pattern = Pattern.compile("\\)");
2000 matcher = pattern.matcher("xxx)xxx");
2001 if (!matcher.find())
2002 failCount++;
2003
2004 report("Negation");
2005 }
2006
2007 private static void ampersandTest() {
2008 Pattern pattern = Pattern.compile("[&@]+");
2009 check(pattern, "@@@@&&&&", true);
2010
2011 pattern = Pattern.compile("[@&]+");
2012 check(pattern, "@@@@&&&&", true);
2013
2014 pattern = Pattern.compile("[@\\&]+");
2015 check(pattern, "@@@@&&&&", true);
2016
2017 report("Ampersand");
2018 }
2019
2020 private static void octalTest() throws Exception {
2021 Pattern pattern = Pattern.compile("\\u0007");
2022 Matcher matcher = pattern.matcher("\u0007");
2023 if (!matcher.matches())
2024 failCount++;
2025 pattern = Pattern.compile("\\07");
2026 matcher = pattern.matcher("\u0007");
2027 if (!matcher.matches())
2028 failCount++;
2029 pattern = Pattern.compile("\\007");
2030 matcher = pattern.matcher("\u0007");
2031 if (!matcher.matches())
2032 failCount++;
2033 pattern = Pattern.compile("\\0007");
2034 matcher = pattern.matcher("\u0007");
2035 if (!matcher.matches())
2036 failCount++;
2037 pattern = Pattern.compile("\\040");
2038 matcher = pattern.matcher("\u0020");
2039 if (!matcher.matches())
2040 failCount++;
2041 pattern = Pattern.compile("\\0403");
2042 matcher = pattern.matcher("\u00203");
2043 if (!matcher.matches())
2044 failCount++;
2045 pattern = Pattern.compile("\\0103");
2046 matcher = pattern.matcher("\u0043");
2047 if (!matcher.matches())
2048 failCount++;
2049
2050 report("Octal");
2051 }
2052
2053 private static void longPatternTest() throws Exception {
2054 try {
2055 Pattern pattern = Pattern.compile(
2056 "a 32-character-long pattern xxxx");
2057 pattern = Pattern.compile("a 33-character-long pattern xxxxx");
2058 pattern = Pattern.compile("a thirty four character long regex");
2059 StringBuffer patternToBe = new StringBuffer(101);
2060 for (int i=0; i<100; i++)
2061 patternToBe.append((char)(97 + i%26));
2062 pattern = Pattern.compile(patternToBe.toString());
2063 } catch (PatternSyntaxException e) {
2064 failCount++;
2065 }
2066
2067 // Supplementary character test
2068 try {
2069 Pattern pattern = Pattern.compile(
2070 toSupplementaries("a 32-character-long pattern xxxx"));
2071 pattern = Pattern.compile(toSupplementaries("a 33-character-long pattern xxxxx"));
2072 pattern = Pattern.compile(toSupplementaries("a thirty four character long regex"));
2073 StringBuffer patternToBe = new StringBuffer(101*2);
2074 for (int i=0; i<100; i++)
2075 patternToBe.append(Character.toChars(Character.MIN_SUPPLEMENTARY_CODE_POINT
2076 + 97 + i%26));
2077 pattern = Pattern.compile(patternToBe.toString());
2078 } catch (PatternSyntaxException e) {
2079 failCount++;
2080 }
2081 report("LongPattern");
2082 }
2083
2084 private static void group0Test() throws Exception {
2085 Pattern pattern = Pattern.compile("(tes)ting");
2086 Matcher matcher = pattern.matcher("testing");
2087 check(matcher, "testing");
2088
2089 matcher.reset("testing");
2090 if (matcher.lookingAt()) {
2091 if (!matcher.group(0).equals("testing"))
2092 failCount++;
2093 } else {
2094 failCount++;
2095 }
2096
2097 matcher.reset("testing");
2098 if (matcher.matches()) {
2099 if (!matcher.group(0).equals("testing"))
2100 failCount++;
2101 } else {
2102 failCount++;
2103 }
2104
2105 pattern = Pattern.compile("(tes)ting");
2106 matcher = pattern.matcher("testing");
2107 if (matcher.lookingAt()) {
2108 if (!matcher.group(0).equals("testing"))
2109 failCount++;
2110 } else {
2111 failCount++;
2112 }
2113
2114 pattern = Pattern.compile("^(tes)ting");
2115 matcher = pattern.matcher("testing");
2116 if (matcher.matches()) {
2117 if (!matcher.group(0).equals("testing"))
2118 failCount++;
2119 } else {
2120 failCount++;
2121 }
2122
2123 // Supplementary character test
2124 pattern = Pattern.compile(toSupplementaries("(tes)ting"));
2125 matcher = pattern.matcher(toSupplementaries("testing"));
2126 check(matcher, toSupplementaries("testing"));
2127
2128 matcher.reset(toSupplementaries("testing"));
2129 if (matcher.lookingAt()) {
2130 if (!matcher.group(0).equals(toSupplementaries("testing")))
2131 failCount++;
2132 } else {
2133 failCount++;
2134 }
2135
2136 matcher.reset(toSupplementaries("testing"));
2137 if (matcher.matches()) {
2138 if (!matcher.group(0).equals(toSupplementaries("testing")))
2139 failCount++;
2140 } else {
2141 failCount++;
2142 }
2143
2144 pattern = Pattern.compile(toSupplementaries("(tes)ting"));
2145 matcher = pattern.matcher(toSupplementaries("testing"));
2146 if (matcher.lookingAt()) {
2147 if (!matcher.group(0).equals(toSupplementaries("testing")))
2148 failCount++;
2149 } else {
2150 failCount++;
2151 }
2152
2153 pattern = Pattern.compile(toSupplementaries("^(tes)ting"));
2154 matcher = pattern.matcher(toSupplementaries("testing"));
2155 if (matcher.matches()) {
2156 if (!matcher.group(0).equals(toSupplementaries("testing")))
2157 failCount++;
2158 } else {
2159 failCount++;
2160 }
2161
2162 report("Group0");
2163 }
2164
2165 private static void findIntTest() throws Exception {
2166 Pattern p = Pattern.compile("blah");
2167 Matcher m = p.matcher("zzzzblahzzzzzblah");
2168 boolean result = m.find(2);
2169 if (!result)
2170 failCount++;
2171
2172 p = Pattern.compile("$");
2173 m = p.matcher("1234567890");
2174 result = m.find(10);
2175 if (!result)
2176 failCount++;
2177 try {
2178 result = m.find(11);
2179 failCount++;
2180 } catch (IndexOutOfBoundsException e) {
2181 // correct result
2182 }
2183
2184 // Supplementary character test
2185 p = Pattern.compile(toSupplementaries("blah"));
2186 m = p.matcher(toSupplementaries("zzzzblahzzzzzblah"));
2187 result = m.find(2);
2188 if (!result)
2189 failCount++;
2190
2191 report("FindInt");
2192 }
2193
2194 private static void emptyPatternTest() throws Exception {
2195 Pattern p = Pattern.compile("");
2196 Matcher m = p.matcher("foo");
2197
2198 // Should find empty pattern at beginning of input
2199 boolean result = m.find();
2200 if (result != true)
2201 failCount++;
2202 if (m.start() != 0)
2203 failCount++;
2204
2205 // Should not match entire input if input is not empty
2206 m.reset();
2207 result = m.matches();
2208 if (result == true)
2209 failCount++;
2210
2211 try {
2212 m.start(0);
2213 failCount++;
2214 } catch (IllegalStateException e) {
2215 // Correct result
2216 }
2217
2218 // Should match entire input if input is empty
2219 m.reset("");
2220 result = m.matches();
2221 if (result != true)
2222 failCount++;
2223
2224 result = Pattern.matches("", "");
2225 if (result != true)
2226 failCount++;
2227
2228 result = Pattern.matches("", "foo");
2229 if (result == true)
2230 failCount++;
2231 report("EmptyPattern");
2232 }
2233
2234 private static void charClassTest() throws Exception {
2235 Pattern pattern = Pattern.compile("blah[ab]]blech");
2236 check(pattern, "blahb]blech", true);
2237
2238 pattern = Pattern.compile("[abc[def]]");
2239 check(pattern, "b", true);
2240
2241 // Supplementary character tests
2242 pattern = Pattern.compile(toSupplementaries("blah[ab]]blech"));
2243 check(pattern, toSupplementaries("blahb]blech"), true);
2244
2245 pattern = Pattern.compile(toSupplementaries("[abc[def]]"));
2246 check(pattern, toSupplementaries("b"), true);
2247
2248 try {
2249 // u00ff when UNICODE_CASE
2250 pattern = Pattern.compile("[ab\u00ffcd]",
2251 Pattern.CASE_INSENSITIVE|
2252 Pattern.UNICODE_CASE);
2253 check(pattern, "ab\u00ffcd", true);
2254 check(pattern, "Ab\u0178Cd", true);
2255
2256 // u00b5 when UNICODE_CASE
2257 pattern = Pattern.compile("[ab\u00b5cd]",
2258 Pattern.CASE_INSENSITIVE|
2259 Pattern.UNICODE_CASE);
2260 check(pattern, "ab\u00b5cd", true);
2261 check(pattern, "Ab\u039cCd", true);
2262 } catch (Exception e) { failCount++; }
2263
2264 /* Special cases
2265 (1)LatinSmallLetterLongS u+017f
2266 (2)LatinSmallLetterDotlessI u+0131
2267 (3)LatineCapitalLetterIWithDotAbove u+0130
2268 (4)KelvinSign u+212a
2269 (5)AngstromSign u+212b
2270 */
2271 int flags = Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE;
2272 pattern = Pattern.compile("[sik\u00c5]+", flags);
2273 if (!pattern.matcher("\u017f\u0130\u0131\u212a\u212b").matches())
2274 failCount++;
2275
2276 report("CharClass");
2277 }
2278
2279 private static void caretTest() throws Exception {
2280 Pattern pattern = Pattern.compile("\\w*");
2281 Matcher matcher = pattern.matcher("a#bc#def##g");
2282 check(matcher, "a");
2283 check(matcher, "");
2284 check(matcher, "bc");
2285 check(matcher, "");
2286 check(matcher, "def");
2287 check(matcher, "");
2288 check(matcher, "");
2289 check(matcher, "g");
2290 check(matcher, "");
2291 if (matcher.find())
2292 failCount++;
2293
2294 pattern = Pattern.compile("^\\w*");
2295 matcher = pattern.matcher("a#bc#def##g");
2296 check(matcher, "a");
2297 if (matcher.find())
2298 failCount++;
2299
2300 pattern = Pattern.compile("\\w");
2301 matcher = pattern.matcher("abc##x");
2302 check(matcher, "a");
2303 check(matcher, "b");
2304 check(matcher, "c");
2305 check(matcher, "x");
2306 if (matcher.find())
2307 failCount++;
2308
2309 pattern = Pattern.compile("^\\w");
2310 matcher = pattern.matcher("abc##x");
2311 check(matcher, "a");
2312 if (matcher.find())
2313 failCount++;
2314
2315 pattern = Pattern.compile("\\A\\p{Alpha}{3}");
2316 matcher = pattern.matcher("abcdef-ghi\njklmno");
2317 check(matcher, "abc");
2318 if (matcher.find())
2319 failCount++;
2320
2321 pattern = Pattern.compile("^\\p{Alpha}{3}", Pattern.MULTILINE);
2322 matcher = pattern.matcher("abcdef-ghi\njklmno");
2323 check(matcher, "abc");
2324 check(matcher, "jkl");
2325 if (matcher.find())
2326 failCount++;
2327
2328 pattern = Pattern.compile("^", Pattern.MULTILINE);
2329 matcher = pattern.matcher("this is some text");
2330 String result = matcher.replaceAll("X");
2331 if (!result.equals("Xthis is some text"))
2332 failCount++;
2333
2334 pattern = Pattern.compile("^");
2335 matcher = pattern.matcher("this is some text");
2336 result = matcher.replaceAll("X");
2337 if (!result.equals("Xthis is some text"))
2338 failCount++;
2339
2340 pattern = Pattern.compile("^", Pattern.MULTILINE | Pattern.UNIX_LINES);
2341 matcher = pattern.matcher("this is some text\n");
2342 result = matcher.replaceAll("X");
2343 if (!result.equals("Xthis is some text\n"))
2344 failCount++;
2345
2346 report("Caret");
2347 }
2348
2349 private static void groupCaptureTest() throws Exception {
2350 // Independent group
2351 Pattern pattern = Pattern.compile("x+(?>y+)z+");
2352 Matcher matcher = pattern.matcher("xxxyyyzzz");
2353 matcher.find();
2354 try {
2355 String blah = matcher.group(1);
2356 failCount++;
2357 } catch (IndexOutOfBoundsException ioobe) {
2358 // Good result
2359 }
2360 // Pure group
2361 pattern = Pattern.compile("x+(?:y+)z+");
2362 matcher = pattern.matcher("xxxyyyzzz");
2363 matcher.find();
2364 try {
2365 String blah = matcher.group(1);
2366 failCount++;
2367 } catch (IndexOutOfBoundsException ioobe) {
2368 // Good result
2369 }
2370
2371 // Supplementary character tests
2372 // Independent group
2373 pattern = Pattern.compile(toSupplementaries("x+(?>y+)z+"));
2374 matcher = pattern.matcher(toSupplementaries("xxxyyyzzz"));
2375 matcher.find();
2376 try {
2377 String blah = matcher.group(1);
2378 failCount++;
2379 } catch (IndexOutOfBoundsException ioobe) {
2380 // Good result
2381 }
2382 // Pure group
2383 pattern = Pattern.compile(toSupplementaries("x+(?:y+)z+"));
2384 matcher = pattern.matcher(toSupplementaries("xxxyyyzzz"));
2385 matcher.find();
2386 try {
2387 String blah = matcher.group(1);
2388 failCount++;
2389 } catch (IndexOutOfBoundsException ioobe) {
2390 // Good result
2391 }
2392
2393 report("GroupCapture");
2394 }
2395
2396 private static void backRefTest() throws Exception {
2397 Pattern pattern = Pattern.compile("(a*)bc\\1");
2398 check(pattern, "zzzaabcazzz", true);
2399
2400 pattern = Pattern.compile("(a*)bc\\1");
2401 check(pattern, "zzzaabcaazzz", true);
2402
2403 pattern = Pattern.compile("(abc)(def)\\1");
2404 check(pattern, "abcdefabc", true);
2405
2406 pattern = Pattern.compile("(abc)(def)\\3");
2407 check(pattern, "abcdefabc", false);
2408
2409 try {
2410 for (int i = 1; i < 10; i++) {
2411 // Make sure backref 1-9 are always accepted
2412 pattern = Pattern.compile("abcdef\\" + i);
2413 // and fail to match if the target group does not exit
2414 check(pattern, "abcdef", false);
2415 }
2416 } catch(PatternSyntaxException e) {
2417 failCount++;
2418 }
2419
2420 pattern = Pattern.compile("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\\11");
2421 check(pattern, "abcdefghija", false);
2422 check(pattern, "abcdefghija1", true);
2423
2424 pattern = Pattern.compile("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11");
2425 check(pattern, "abcdefghijkk", true);
2426
2427 pattern = Pattern.compile("(a)bcdefghij\\11");
2428 check(pattern, "abcdefghija1", true);
2429
2430 // Supplementary character tests
2431 pattern = Pattern.compile(toSupplementaries("(a*)bc\\1"));
2432 check(pattern, toSupplementaries("zzzaabcazzz"), true);
2433
2434 pattern = Pattern.compile(toSupplementaries("(a*)bc\\1"));
2435 check(pattern, toSupplementaries("zzzaabcaazzz"), true);
2436
2437 pattern = Pattern.compile(toSupplementaries("(abc)(def)\\1"));
2438 check(pattern, toSupplementaries("abcdefabc"), true);
2439
2440 pattern = Pattern.compile(toSupplementaries("(abc)(def)\\3"));
2441 check(pattern, toSupplementaries("abcdefabc"), false);
2442
2443 pattern = Pattern.compile(toSupplementaries("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\\11"));
2444 check(pattern, toSupplementaries("abcdefghija"), false);
2445 check(pattern, toSupplementaries("abcdefghija1"), true);
2446
2447 pattern = Pattern.compile(toSupplementaries("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11"));
2448 check(pattern, toSupplementaries("abcdefghijkk"), true);
2449
2450 report("BackRef");
2451 }
2452
2453 /**
2454 * Unicode Technical Report #18, section 2.6 End of Line
2455 * There is no empty line to be matched in the sequence \u000D\u000A
2456 * but there is an empty line in the sequence \u000A\u000D.
2457 */
2458 private static void anchorTest() throws Exception {
2459 Pattern p = Pattern.compile("^.*$", Pattern.MULTILINE);
2460 Matcher m = p.matcher("blah1\r\nblah2");
2461 m.find();
2462 m.find();
2463 if (!m.group().equals("blah2"))
2464 failCount++;
2465
2466 m.reset("blah1\n\rblah2");
2467 m.find();
2468 m.find();
2469 m.find();
2470 if (!m.group().equals("blah2"))
2471 failCount++;
2472
2473 // Test behavior of $ with \r\n at end of input
2474 p = Pattern.compile(".+$");
2475 m = p.matcher("blah1\r\n");
2476 if (!m.find())
2477 failCount++;
2478 if (!m.group().equals("blah1"))
2479 failCount++;
2480 if (m.find())
2481 failCount++;
2482
2483 // Test behavior of $ with \r\n at end of input in multiline
2484 p = Pattern.compile(".+$", Pattern.MULTILINE);
2485 m = p.matcher("blah1\r\n");
2486 if (!m.find())
2487 failCount++;
2488 if (m.find())
2489 failCount++;
2490
2491 // Test for $ recognition of \u0085 for bug 4527731
2492 p = Pattern.compile(".+$", Pattern.MULTILINE);
2493 m = p.matcher("blah1\u0085");
2494 if (!m.find())
2495 failCount++;
2496
2497 // Supplementary character test
2498 p = Pattern.compile("^.*$", Pattern.MULTILINE);
2499 m = p.matcher(toSupplementaries("blah1\r\nblah2"));
2500 m.find();
2501 m.find();
2502 if (!m.group().equals(toSupplementaries("blah2")))
2503 failCount++;
2504
2505 m.reset(toSupplementaries("blah1\n\rblah2"));
2506 m.find();
2507 m.find();
2508 m.find();
2509 if (!m.group().equals(toSupplementaries("blah2")))
2510 failCount++;
2511
2512 // Test behavior of $ with \r\n at end of input
2513 p = Pattern.compile(".+$");
2514 m = p.matcher(toSupplementaries("blah1\r\n"));
2515 if (!m.find())
2516 failCount++;
2517 if (!m.group().equals(toSupplementaries("blah1")))
2518 failCount++;
2519 if (m.find())
2520 failCount++;
2521
2522 // Test behavior of $ with \r\n at end of input in multiline
2523 p = Pattern.compile(".+$", Pattern.MULTILINE);
2524 m = p.matcher(toSupplementaries("blah1\r\n"));
2525 if (!m.find())
2526 failCount++;
2527 if (m.find())
2528 failCount++;
2529
2530 // Test for $ recognition of \u0085 for bug 4527731
2531 p = Pattern.compile(".+$", Pattern.MULTILINE);
2532 m = p.matcher(toSupplementaries("blah1\u0085"));
2533 if (!m.find())
2534 failCount++;
2535
2536 report("Anchors");
2537 }
2538
2539 /**
2540 * A basic sanity test of Matcher.lookingAt().
2541 */
2542 private static void lookingAtTest() throws Exception {
2543 Pattern p = Pattern.compile("(ab)(c*)");
2544 Matcher m = p.matcher("abccczzzabcczzzabccc");
2545
2546 if (!m.lookingAt())
2547 failCount++;
2548
2549 if (!m.group().equals(m.group(0)))
2550 failCount++;
2551
2552 m = p.matcher("zzzabccczzzabcczzzabccczzz");
2553 if (m.lookingAt())
2554 failCount++;
2555
2556 // Supplementary character test
2557 p = Pattern.compile(toSupplementaries("(ab)(c*)"));
2558 m = p.matcher(toSupplementaries("abccczzzabcczzzabccc"));
2559
2560 if (!m.lookingAt())
2561 failCount++;
2562
2563 if (!m.group().equals(m.group(0)))
2564 failCount++;
2565
2566 m = p.matcher(toSupplementaries("zzzabccczzzabcczzzabccczzz"));
2567 if (m.lookingAt())
2568 failCount++;
2569
2570 report("Looking At");
2571 }
2572
2573 /**
2574 * A basic sanity test of Matcher.matches().
2575 */
2576 private static void matchesTest() throws Exception {
2577 // matches()
2578 Pattern p = Pattern.compile("ulb(c*)");
2579 Matcher m = p.matcher("ulbcccccc");
2580 if (!m.matches())
2581 failCount++;
2582
2583 // find() but not matches()
2584 m.reset("zzzulbcccccc");
2585 if (m.matches())
2586 failCount++;
2587
2588 // lookingAt() but not matches()
2589 m.reset("ulbccccccdef");
2590 if (m.matches())
2591 failCount++;
2592
2593 // matches()
2594 p = Pattern.compile("a|ad");
2595 m = p.matcher("ad");
2596 if (!m.matches())
2597 failCount++;
2598
2599 // Supplementary character test
2600 // matches()
2601 p = Pattern.compile(toSupplementaries("ulb(c*)"));
2602 m = p.matcher(toSupplementaries("ulbcccccc"));
2603 if (!m.matches())
2604 failCount++;
2605
2606 // find() but not matches()
2607 m.reset(toSupplementaries("zzzulbcccccc"));
2608 if (m.matches())
2609 failCount++;
2610
2611 // lookingAt() but not matches()
2612 m.reset(toSupplementaries("ulbccccccdef"));
2613 if (m.matches())
2614 failCount++;
2615
2616 // matches()
2617 p = Pattern.compile(toSupplementaries("a|ad"));
2618 m = p.matcher(toSupplementaries("ad"));
2619 if (!m.matches())
2620 failCount++;
2621
2622 report("Matches");
2623 }
2624
2625 /**
2626 * A basic sanity test of Pattern.matches().
2627 */
2628 private static void patternMatchesTest() throws Exception {
2629 // matches()
2630 if (!Pattern.matches(toSupplementaries("ulb(c*)"),
2631 toSupplementaries("ulbcccccc")))
2632 failCount++;
2633
2634 // find() but not matches()
2635 if (Pattern.matches(toSupplementaries("ulb(c*)"),
2636 toSupplementaries("zzzulbcccccc")))
2637 failCount++;
2638
2639 // lookingAt() but not matches()
2640 if (Pattern.matches(toSupplementaries("ulb(c*)"),
2641 toSupplementaries("ulbccccccdef")))
2642 failCount++;
2643
2644 // Supplementary character test
2645 // matches()
2646 if (!Pattern.matches(toSupplementaries("ulb(c*)"),
2647 toSupplementaries("ulbcccccc")))
2648 failCount++;
2649
2650 // find() but not matches()
2651 if (Pattern.matches(toSupplementaries("ulb(c*)"),
2652 toSupplementaries("zzzulbcccccc")))
2653 failCount++;
2654
2655 // lookingAt() but not matches()
2656 if (Pattern.matches(toSupplementaries("ulb(c*)"),
2657 toSupplementaries("ulbccccccdef")))
2658 failCount++;
2659
2660 report("Pattern Matches");
2661 }
2662
2663 /**
2664 * Canonical equivalence testing. Tests the ability of the engine
2665 * to match sequences that are not explicitly specified in the
2666 * pattern when they are considered equivalent by the Unicode Standard.
2667 */
2668 private static void ceTest() throws Exception {
2669 // Decomposed char outside char classes
2670 Pattern p = Pattern.compile("testa\u030a", Pattern.CANON_EQ);
2671 Matcher m = p.matcher("test\u00e5");
2672 if (!m.matches())
2673 failCount++;
2674
2675 m.reset("testa\u030a");
2676 if (!m.matches())
2677 failCount++;
2678
2679 // Composed char outside char classes
2680 p = Pattern.compile("test\u00e5", Pattern.CANON_EQ);
2681 m = p.matcher("test\u00e5");
2682 if (!m.matches())
2683 failCount++;
2684
2685 m.reset("testa\u030a");
2686 if (!m.find())
2687 failCount++;
2688
2689 // Decomposed char inside a char class
2690 p = Pattern.compile("test[abca\u030a]", Pattern.CANON_EQ);
2691 m = p.matcher("test\u00e5");
2692 if (!m.find())
2693 failCount++;
2694
2695 m.reset("testa\u030a");
2696 if (!m.find())
2697 failCount++;
2698
2699 // Composed char inside a char class
2700 p = Pattern.compile("test[abc\u00e5def\u00e0]", Pattern.CANON_EQ);
2701 m = p.matcher("test\u00e5");
2702 if (!m.find())
2703 failCount++;
2704
2705 m.reset("testa\u0300");
2706 if (!m.find())
2707 failCount++;
2708
2709 m.reset("testa\u030a");
2710 if (!m.find())
2711 failCount++;
2712
2713 // Marks that cannot legally change order and be equivalent
2714 p = Pattern.compile("testa\u0308\u0300", Pattern.CANON_EQ);
2715 check(p, "testa\u0308\u0300", true);
2716 check(p, "testa\u0300\u0308", false);
2717
2718 // Marks that can legally change order and be equivalent
2719 p = Pattern.compile("testa\u0308\u0323", Pattern.CANON_EQ);
2720 check(p, "testa\u0308\u0323", true);
2721 check(p, "testa\u0323\u0308", true);
2722
2723 // Test all equivalences of the sequence a\u0308\u0323\u0300
2724 p = Pattern.compile("testa\u0308\u0323\u0300", Pattern.CANON_EQ);
2725 check(p, "testa\u0308\u0323\u0300", true);
2726 check(p, "testa\u0323\u0308\u0300", true);
2727 check(p, "testa\u0308\u0300\u0323", true);
2728 check(p, "test\u00e4\u0323\u0300", true);
2729 check(p, "test\u00e4\u0300\u0323", true);
2730
2731 Object[][] data = new Object[][] {
2732
2733 // JDK-4867170
2734 { "[\u1f80-\u1f82]", "ab\u1f80cd", "f", true },
2735 { "[\u1f80-\u1f82]", "ab\u1f81cd", "f", true },
2736 { "[\u1f80-\u1f82]", "ab\u1f82cd", "f", true },
2737 { "[\u1f80-\u1f82]", "ab\u03b1\u0314\u0345cd", "f", true },
2738 { "[\u1f80-\u1f82]", "ab\u03b1\u0345\u0314cd", "f", true },
2739 { "[\u1f80-\u1f82]", "ab\u1f01\u0345cd", "f", true },
2740 { "[\u1f80-\u1f82]", "ab\u1f00\u0345cd", "f", true },
2741
2742 { "\\p{IsGreek}", "ab\u1f80cd", "f", true },
2743 { "\\p{IsGreek}", "ab\u1f81cd", "f", true },
2744 { "\\p{IsGreek}", "ab\u1f82cd", "f", true },
2745 { "\\p{IsGreek}", "ab\u03b1\u0314\u0345cd", "f", true },
2746 { "\\p{IsGreek}", "ab\u1f01\u0345cd", "f", true },
2747
2748 // backtracking, force to match "\u1f80", instead of \u1f82"
2749 { "ab\\p{IsGreek}\u0300cd", "ab\u03b1\u0313\u0345\u0300cd", "m", true },
2750
2751 { "[\\p{IsGreek}]", "\u03b1\u0314\u0345", "m", true },
2752 { "\\p{IsGreek}", "\u03b1\u0314\u0345", "m", true },
2753
2754 { "[^\u1f80-\u1f82]","\u1f81", "m", false },
2755 { "[^\u1f80-\u1f82]","\u03b1\u0314\u0345", "m", false },
2756 { "[^\u1f01\u0345]", "\u1f81", "f", false },
2757
2758 { "[^\u1f81]+", "\u1f80\u1f82", "f", true },
2759 { "[\u1f80]", "ab\u1f80cd", "f", true },
2760 { "\u1f80", "ab\u1f80cd", "f", true },
2761 { "\u1f00\u0345\u0300", "\u1f82", "m", true },
2762 { "\u1f80", "-\u1f00\u0345\u0300-", "f", true },
2763 { "\u1f82", "\u1f00\u0345\u0300", "m", true },
2764 { "\u1f82", "\u1f80\u0300", "m", true },
2765
2766 // JDK-7080302 # compile failed
2767 { "a(\u0041\u0301\u0328)", "a\u0041\u0301\u0328", "m", true},
2768
2769 // JDK-6728861, same cause as above one
2770 { "\u00e9\u00e9n", "e\u0301e\u0301n", "m", true},
2771
2772 // JDK-6995635
2773 { "(\u00e9)", "e\u0301", "m", true },
2774
2775 // JDK-6736245
2776 // intereting special case, nfc(u2add+u0338) -> u2add+u0338) NOT u2adc
2777 { "\u2ADC", "\u2ADC", "m", true}, // NFC
2778 { "\u2ADC", "\u2ADD\u0338", "m", true}, // NFD
2779
2780 // 4916384.
2781 // Decomposed hangul (jamos) works inside clazz
2782 { "[\u1100\u1161]", "\u1100\u1161", "m", true},
2783 { "[\u1100\u1161]", "\uac00", "m", true},
2784
2785 { "[\uac00]", "\u1100\u1161", "m", true},
2786 { "[\uac00]", "\uac00", "m", true},
2787
2788 // Decomposed hangul (jamos)
2789 { "\u1100\u1161", "\u1100\u1161", "m", true},
2790 { "\u1100\u1161", "\uac00", "m", true},
2791
2792 // Composed hangul
2793 { "\uac00", "\u1100\u1161", "m", true },
2794 { "\uac00", "\uac00", "m", true },
2795
2796 /* Need a NFDSlice to nfd the source to solve this issue
2797 u+1d1c0 -> nfd: <u+1d1ba><u+1d165><u+1d16f> -> nfc: <u+1d1ba><u+1d165><u+1d16f>
2798 u+1d1bc -> nfd: <u+1d1ba><u+1d165> -> nfc: <u+1d1ba><u+1d165>
2799 <u+1d1bc><u+1d16f> -> nfd: <u+1d1ba><u+1d165><u+1d16f> -> nfc: <u+1d1ba><u+1d165><u+1d16f>
2800
2801 // Decomposed supplementary outside char classes
2802 // { "test\ud834\uddbc\ud834\udd6f", "test\ud834\uddc0", "m", true },
2803 // Composed supplementary outside char classes
2804 // { "test\ud834\uddc0", "test\ud834\uddbc\ud834\udd6f", "m", true },
2805 */
2806 { "test\ud834\uddbc\ud834\udd6f", "test\ud834\uddbc\ud834\udd6f", "m", true },
2807 { "test\ud834\uddc0", "test\ud834\uddbc\ud834\udd6f", "m", true },
2808
2809 { "test\ud834\uddc0", "test\ud834\uddc0", "m", true },
2810 { "test\ud834\uddbc\ud834\udd6f", "test\ud834\uddc0", "m", true },
2811 };
2812
2813 int failCount = 0;
2814 for (Object[] d : data) {
2815 String pn = (String)d[0];
2816 String tt = (String)d[1];
2817 boolean isFind = "f".equals(((String)d[2]));
2818 boolean expected = (boolean)d[3];
2819 boolean ret = isFind ? Pattern.compile(pn, Pattern.CANON_EQ).matcher(tt).find()
2820 : Pattern.compile(pn, Pattern.CANON_EQ).matcher(tt).matches();
2821 if (ret != expected) {
2822 failCount++;
2823 continue;
2824 }
2825 }
2826 report("Canonical Equivalence");
2827 }
2828
2829 /**
2830 * A basic sanity test of Matcher.replaceAll().
2831 */
2832 private static void globalSubstitute() throws Exception {
2833 // Global substitution with a literal
2834 Pattern p = Pattern.compile("(ab)(c*)");
2835 Matcher m = p.matcher("abccczzzabcczzzabccc");
2836 if (!m.replaceAll("test").equals("testzzztestzzztest"))
2837 failCount++;
2838
2839 m.reset("zzzabccczzzabcczzzabccczzz");
2840 if (!m.replaceAll("test").equals("zzztestzzztestzzztestzzz"))
2841 failCount++;
2842
2843 // Global substitution with groups
2844 m.reset("zzzabccczzzabcczzzabccczzz");
2845 String result = m.replaceAll("$1");
2846 if (!result.equals("zzzabzzzabzzzabzzz"))
2847 failCount++;
2848
2849 // Supplementary character test
2850 // Global substitution with a literal
2851 p = Pattern.compile(toSupplementaries("(ab)(c*)"));
2852 m = p.matcher(toSupplementaries("abccczzzabcczzzabccc"));
2853 if (!m.replaceAll(toSupplementaries("test")).
2854 equals(toSupplementaries("testzzztestzzztest")))
2855 failCount++;
2856
2857 m.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz"));
2858 if (!m.replaceAll(toSupplementaries("test")).
2859 equals(toSupplementaries("zzztestzzztestzzztestzzz")))
2860 failCount++;
2861
2862 // Global substitution with groups
2863 m.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz"));
2864 result = m.replaceAll("$1");
2865 if (!result.equals(toSupplementaries("zzzabzzzabzzzabzzz")))
2866 failCount++;
2867
2868 report("Global Substitution");
2869 }
2870
2871 /**
2872 * Tests the usage of Matcher.appendReplacement() with literal
2873 * and group substitutions.
2874 */
2875 private static void stringbufferSubstitute() throws Exception {
2876 // SB substitution with literal
2877 String blah = "zzzblahzzz";
2878 Pattern p = Pattern.compile("blah");
2879 Matcher m = p.matcher(blah);
2880 StringBuffer result = new StringBuffer();
2881 try {
2882 m.appendReplacement(result, "blech");
2883 failCount++;
2884 } catch (IllegalStateException e) {
2885 }
2886 m.find();
2887 m.appendReplacement(result, "blech");
2888 if (!result.toString().equals("zzzblech"))
2889 failCount++;
2890
2891 m.appendTail(result);
2892 if (!result.toString().equals("zzzblechzzz"))
2893 failCount++;
2894
2895 // SB substitution with groups
2896 blah = "zzzabcdzzz";
2897 p = Pattern.compile("(ab)(cd)*");
2898 m = p.matcher(blah);
2899 result = new StringBuffer();
2900 try {
2901 m.appendReplacement(result, "$1");
2902 failCount++;
2903 } catch (IllegalStateException e) {
2904 }
2905 m.find();
2906 m.appendReplacement(result, "$1");
2907 if (!result.toString().equals("zzzab"))
2908 failCount++;
2909
2910 m.appendTail(result);
2911 if (!result.toString().equals("zzzabzzz"))
2912 failCount++;
2913
2914 // SB substitution with 3 groups
2915 blah = "zzzabcdcdefzzz";
2916 p = Pattern.compile("(ab)(cd)*(ef)");
2917 m = p.matcher(blah);
2918 result = new StringBuffer();
2919 try {
2920 m.appendReplacement(result, "$1w$2w$3");
2921 failCount++;
2922 } catch (IllegalStateException e) {
2923 }
2924 m.find();
2925 m.appendReplacement(result, "$1w$2w$3");
2926 if (!result.toString().equals("zzzabwcdwef"))
2927 failCount++;
2928
2929 m.appendTail(result);
2930 if (!result.toString().equals("zzzabwcdwefzzz"))
2931 failCount++;
2932
2933 // SB substitution with groups and three matches
2934 // skipping middle match
2935 blah = "zzzabcdzzzabcddzzzabcdzzz";
2936 p = Pattern.compile("(ab)(cd*)");
2937 m = p.matcher(blah);
2938 result = new StringBuffer();
2939 try {
2940 m.appendReplacement(result, "$1");
2941 failCount++;
2942 } catch (IllegalStateException e) {
2943 }
2944 m.find();
2945 m.appendReplacement(result, "$1");
2946 if (!result.toString().equals("zzzab"))
2947 failCount++;
2948
2949 m.find();
2950 m.find();
2951 m.appendReplacement(result, "$2");
2952 if (!result.toString().equals("zzzabzzzabcddzzzcd"))
2953 failCount++;
2954
2955 m.appendTail(result);
2956 if (!result.toString().equals("zzzabzzzabcddzzzcdzzz"))
2957 failCount++;
2958
2959 // Check to make sure escaped $ is ignored
2960 blah = "zzzabcdcdefzzz";
2961 p = Pattern.compile("(ab)(cd)*(ef)");
2962 m = p.matcher(blah);
2963 result = new StringBuffer();
2964 m.find();
2965 m.appendReplacement(result, "$1w\\$2w$3");
2966 if (!result.toString().equals("zzzabw$2wef"))
2967 failCount++;
2968
2969 m.appendTail(result);
2970 if (!result.toString().equals("zzzabw$2wefzzz"))
2971 failCount++;
2972
2973 // Check to make sure a reference to nonexistent group causes error
2974 blah = "zzzabcdcdefzzz";
2975 p = Pattern.compile("(ab)(cd)*(ef)");
2976 m = p.matcher(blah);
2977 result = new StringBuffer();
2978 m.find();
2979 try {
2980 m.appendReplacement(result, "$1w$5w$3");
2981 failCount++;
2982 } catch (IndexOutOfBoundsException ioobe) {
2983 // Correct result
2984 }
2985
2986 // Check double digit group references
2987 blah = "zzz123456789101112zzz";
2988 p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)");
2989 m = p.matcher(blah);
2990 result = new StringBuffer();
2991 m.find();
2992 m.appendReplacement(result, "$1w$11w$3");
2993 if (!result.toString().equals("zzz1w11w3"))
2994 failCount++;
2995
2996 // Check to make sure it backs off $15 to $1 if only three groups
2997 blah = "zzzabcdcdefzzz";
2998 p = Pattern.compile("(ab)(cd)*(ef)");
2999 m = p.matcher(blah);
3000 result = new StringBuffer();
3001 m.find();
3002 m.appendReplacement(result, "$1w$15w$3");
3003 if (!result.toString().equals("zzzabwab5wef"))
3004 failCount++;
3005
3006
3007 // Supplementary character test
3008 // SB substitution with literal
3009 blah = toSupplementaries("zzzblahzzz");
3010 p = Pattern.compile(toSupplementaries("blah"));
3011 m = p.matcher(blah);
3012 result = new StringBuffer();
3013 try {
3014 m.appendReplacement(result, toSupplementaries("blech"));
3015 failCount++;
3016 } catch (IllegalStateException e) {
3017 }
3018 m.find();
3019 m.appendReplacement(result, toSupplementaries("blech"));
3020 if (!result.toString().equals(toSupplementaries("zzzblech")))
3021 failCount++;
3022
3023 m.appendTail(result);
3024 if (!result.toString().equals(toSupplementaries("zzzblechzzz")))
3025 failCount++;
3026
3027 // SB substitution with groups
3028 blah = toSupplementaries("zzzabcdzzz");
3029 p = Pattern.compile(toSupplementaries("(ab)(cd)*"));
3030 m = p.matcher(blah);
3031 result = new StringBuffer();
3032 try {
3033 m.appendReplacement(result, "$1");
3034 failCount++;
3035 } catch (IllegalStateException e) {
3036 }
3037 m.find();
3038 m.appendReplacement(result, "$1");
3039 if (!result.toString().equals(toSupplementaries("zzzab")))
3040 failCount++;
3041
3042 m.appendTail(result);
3043 if (!result.toString().equals(toSupplementaries("zzzabzzz")))
3044 failCount++;
3045
3046 // SB substitution with 3 groups
3047 blah = toSupplementaries("zzzabcdcdefzzz");
3048 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)"));
3049 m = p.matcher(blah);
3050 result = new StringBuffer();
3051 try {
3052 m.appendReplacement(result, toSupplementaries("$1w$2w$3"));
3053 failCount++;
3054 } catch (IllegalStateException e) {
3055 }
3056 m.find();
3057 m.appendReplacement(result, toSupplementaries("$1w$2w$3"));
3058 if (!result.toString().equals(toSupplementaries("zzzabwcdwef")))
3059 failCount++;
3060
3061 m.appendTail(result);
3062 if (!result.toString().equals(toSupplementaries("zzzabwcdwefzzz")))
3063 failCount++;
3064
3065 // SB substitution with groups and three matches
3066 // skipping middle match
3067 blah = toSupplementaries("zzzabcdzzzabcddzzzabcdzzz");
3068 p = Pattern.compile(toSupplementaries("(ab)(cd*)"));
3069 m = p.matcher(blah);
3070 result = new StringBuffer();
3071 try {
3072 m.appendReplacement(result, "$1");
3073 failCount++;
3074 } catch (IllegalStateException e) {
3075 }
3076 m.find();
3077 m.appendReplacement(result, "$1");
3078 if (!result.toString().equals(toSupplementaries("zzzab")))
3079 failCount++;
3080
3081 m.find();
3082 m.find();
3083 m.appendReplacement(result, "$2");
3084 if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcd")))
3085 failCount++;
3086
3087 m.appendTail(result);
3088 if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcdzzz")))
3089 failCount++;
3090
3091 // Check to make sure escaped $ is ignored
3092 blah = toSupplementaries("zzzabcdcdefzzz");
3093 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)"));
3094 m = p.matcher(blah);
3095 result = new StringBuffer();
3096 m.find();
3097 m.appendReplacement(result, toSupplementaries("$1w\\$2w$3"));
3098 if (!result.toString().equals(toSupplementaries("zzzabw$2wef")))
3099 failCount++;
3100
3101 m.appendTail(result);
3102 if (!result.toString().equals(toSupplementaries("zzzabw$2wefzzz")))
3103 failCount++;
3104
3105 // Check to make sure a reference to nonexistent group causes error
3106 blah = toSupplementaries("zzzabcdcdefzzz");
3107 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)"));
3108 m = p.matcher(blah);
3109 result = new StringBuffer();
3110 m.find();
3111 try {
3112 m.appendReplacement(result, toSupplementaries("$1w$5w$3"));
3113 failCount++;
3114 } catch (IndexOutOfBoundsException ioobe) {
3115 // Correct result
3116 }
3117
3118 // Check double digit group references
3119 blah = toSupplementaries("zzz123456789101112zzz");
3120 p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)");
3121 m = p.matcher(blah);
3122 result = new StringBuffer();
3123 m.find();
3124 m.appendReplacement(result, toSupplementaries("$1w$11w$3"));
3125 if (!result.toString().equals(toSupplementaries("zzz1w11w3")))
3126 failCount++;
3127
3128 // Check to make sure it backs off $15 to $1 if only three groups
3129 blah = toSupplementaries("zzzabcdcdefzzz");
3130 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)"));
3131 m = p.matcher(blah);
3132 result = new StringBuffer();
3133 m.find();
3134 m.appendReplacement(result, toSupplementaries("$1w$15w$3"));
3135 if (!result.toString().equals(toSupplementaries("zzzabwab5wef")))
3136 failCount++;
3137
3138 // Check nothing has been appended into the output buffer if
3139 // the replacement string triggers IllegalArgumentException.
3140 p = Pattern.compile("(abc)");
3141 m = p.matcher("abcd");
3142 result = new StringBuffer();
3143 m.find();
3144 try {
3145 m.appendReplacement(result, ("xyz$g"));
3146 failCount++;
3147 } catch (IllegalArgumentException iae) {
3148 if (result.length() != 0)
3149 failCount++;
3150 }
3151
3152 report("SB Substitution");
3153 }
3154
3155 /**
3156 * Tests the usage of Matcher.appendReplacement() with literal
3157 * and group substitutions.
3158 */
3159 private static void stringbuilderSubstitute() throws Exception {
3160 // SB substitution with literal
3161 String blah = "zzzblahzzz";
3162 Pattern p = Pattern.compile("blah");
3163 Matcher m = p.matcher(blah);
3164 StringBuilder result = new StringBuilder();
3165 try {
3166 m.appendReplacement(result, "blech");
3167 failCount++;
3168 } catch (IllegalStateException e) {
3169 }
3170 m.find();
3171 m.appendReplacement(result, "blech");
3172 if (!result.toString().equals("zzzblech"))
3173 failCount++;
3174
3175 m.appendTail(result);
3176 if (!result.toString().equals("zzzblechzzz"))
3177 failCount++;
3178
3179 // SB substitution with groups
3180 blah = "zzzabcdzzz";
3181 p = Pattern.compile("(ab)(cd)*");
3182 m = p.matcher(blah);
3183 result = new StringBuilder();
3184 try {
3185 m.appendReplacement(result, "$1");
3186 failCount++;
3187 } catch (IllegalStateException e) {
3188 }
3189 m.find();
3190 m.appendReplacement(result, "$1");
3191 if (!result.toString().equals("zzzab"))
3192 failCount++;
3193
3194 m.appendTail(result);
3195 if (!result.toString().equals("zzzabzzz"))
3196 failCount++;
3197
3198 // SB substitution with 3 groups
3199 blah = "zzzabcdcdefzzz";
3200 p = Pattern.compile("(ab)(cd)*(ef)");
3201 m = p.matcher(blah);
3202 result = new StringBuilder();
3203 try {
3204 m.appendReplacement(result, "$1w$2w$3");
3205 failCount++;
3206 } catch (IllegalStateException e) {
3207 }
3208 m.find();
3209 m.appendReplacement(result, "$1w$2w$3");
3210 if (!result.toString().equals("zzzabwcdwef"))
3211 failCount++;
3212
3213 m.appendTail(result);
3214 if (!result.toString().equals("zzzabwcdwefzzz"))
3215 failCount++;
3216
3217 // SB substitution with groups and three matches
3218 // skipping middle match
3219 blah = "zzzabcdzzzabcddzzzabcdzzz";
3220 p = Pattern.compile("(ab)(cd*)");
3221 m = p.matcher(blah);
3222 result = new StringBuilder();
3223 try {
3224 m.appendReplacement(result, "$1");
3225 failCount++;
3226 } catch (IllegalStateException e) {
3227 }
3228 m.find();
3229 m.appendReplacement(result, "$1");
3230 if (!result.toString().equals("zzzab"))
3231 failCount++;
3232
3233 m.find();
3234 m.find();
3235 m.appendReplacement(result, "$2");
3236 if (!result.toString().equals("zzzabzzzabcddzzzcd"))
3237 failCount++;
3238
3239 m.appendTail(result);
3240 if (!result.toString().equals("zzzabzzzabcddzzzcdzzz"))
3241 failCount++;
3242
3243 // Check to make sure escaped $ is ignored
3244 blah = "zzzabcdcdefzzz";
3245 p = Pattern.compile("(ab)(cd)*(ef)");
3246 m = p.matcher(blah);
3247 result = new StringBuilder();
3248 m.find();
3249 m.appendReplacement(result, "$1w\\$2w$3");
3250 if (!result.toString().equals("zzzabw$2wef"))
3251 failCount++;
3252
3253 m.appendTail(result);
3254 if (!result.toString().equals("zzzabw$2wefzzz"))
3255 failCount++;
3256
3257 // Check to make sure a reference to nonexistent group causes error
3258 blah = "zzzabcdcdefzzz";
3259 p = Pattern.compile("(ab)(cd)*(ef)");
3260 m = p.matcher(blah);
3261 result = new StringBuilder();
3262 m.find();
3263 try {
3264 m.appendReplacement(result, "$1w$5w$3");
3265 failCount++;
3266 } catch (IndexOutOfBoundsException ioobe) {
3267 // Correct result
3268 }
3269
3270 // Check double digit group references
3271 blah = "zzz123456789101112zzz";
3272 p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)");
3273 m = p.matcher(blah);
3274 result = new StringBuilder();
3275 m.find();
3276 m.appendReplacement(result, "$1w$11w$3");
3277 if (!result.toString().equals("zzz1w11w3"))
3278 failCount++;
3279
3280 // Check to make sure it backs off $15 to $1 if only three groups
3281 blah = "zzzabcdcdefzzz";
3282 p = Pattern.compile("(ab)(cd)*(ef)");
3283 m = p.matcher(blah);
3284 result = new StringBuilder();
3285 m.find();
3286 m.appendReplacement(result, "$1w$15w$3");
3287 if (!result.toString().equals("zzzabwab5wef"))
3288 failCount++;
3289
3290
3291 // Supplementary character test
3292 // SB substitution with literal
3293 blah = toSupplementaries("zzzblahzzz");
3294 p = Pattern.compile(toSupplementaries("blah"));
3295 m = p.matcher(blah);
3296 result = new StringBuilder();
3297 try {
3298 m.appendReplacement(result, toSupplementaries("blech"));
3299 failCount++;
3300 } catch (IllegalStateException e) {
3301 }
3302 m.find();
3303 m.appendReplacement(result, toSupplementaries("blech"));
3304 if (!result.toString().equals(toSupplementaries("zzzblech")))
3305 failCount++;
3306 m.appendTail(result);
3307 if (!result.toString().equals(toSupplementaries("zzzblechzzz")))
3308 failCount++;
3309
3310 // SB substitution with groups
3311 blah = toSupplementaries("zzzabcdzzz");
3312 p = Pattern.compile(toSupplementaries("(ab)(cd)*"));
3313 m = p.matcher(blah);
3314 result = new StringBuilder();
3315 try {
3316 m.appendReplacement(result, "$1");
3317 failCount++;
3318 } catch (IllegalStateException e) {
3319 }
3320 m.find();
3321 m.appendReplacement(result, "$1");
3322 if (!result.toString().equals(toSupplementaries("zzzab")))
3323 failCount++;
3324
3325 m.appendTail(result);
3326 if (!result.toString().equals(toSupplementaries("zzzabzzz")))
3327 failCount++;
3328
3329 // SB substitution with 3 groups
3330 blah = toSupplementaries("zzzabcdcdefzzz");
3331 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)"));
3332 m = p.matcher(blah);
3333 result = new StringBuilder();
3334 try {
3335 m.appendReplacement(result, toSupplementaries("$1w$2w$3"));
3336 failCount++;
3337 } catch (IllegalStateException e) {
3338 }
3339 m.find();
3340 m.appendReplacement(result, toSupplementaries("$1w$2w$3"));
3341 if (!result.toString().equals(toSupplementaries("zzzabwcdwef")))
3342 failCount++;
3343
3344 m.appendTail(result);
3345 if (!result.toString().equals(toSupplementaries("zzzabwcdwefzzz")))
3346 failCount++;
3347
3348 // SB substitution with groups and three matches
3349 // skipping middle match
3350 blah = toSupplementaries("zzzabcdzzzabcddzzzabcdzzz");
3351 p = Pattern.compile(toSupplementaries("(ab)(cd*)"));
3352 m = p.matcher(blah);
3353 result = new StringBuilder();
3354 try {
3355 m.appendReplacement(result, "$1");
3356 failCount++;
3357 } catch (IllegalStateException e) {
3358 }
3359 m.find();
3360 m.appendReplacement(result, "$1");
3361 if (!result.toString().equals(toSupplementaries("zzzab")))
3362 failCount++;
3363
3364 m.find();
3365 m.find();
3366 m.appendReplacement(result, "$2");
3367 if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcd")))
3368 failCount++;
3369
3370 m.appendTail(result);
3371 if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcdzzz")))
3372 failCount++;
3373
3374 // Check to make sure escaped $ is ignored
3375 blah = toSupplementaries("zzzabcdcdefzzz");
3376 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)"));
3377 m = p.matcher(blah);
3378 result = new StringBuilder();
3379 m.find();
3380 m.appendReplacement(result, toSupplementaries("$1w\\$2w$3"));
3381 if (!result.toString().equals(toSupplementaries("zzzabw$2wef")))
3382 failCount++;
3383
3384 m.appendTail(result);
3385 if (!result.toString().equals(toSupplementaries("zzzabw$2wefzzz")))
3386 failCount++;
3387
3388 // Check to make sure a reference to nonexistent group causes error
3389 blah = toSupplementaries("zzzabcdcdefzzz");
3390 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)"));
3391 m = p.matcher(blah);
3392 result = new StringBuilder();
3393 m.find();
3394 try {
3395 m.appendReplacement(result, toSupplementaries("$1w$5w$3"));
3396 failCount++;
3397 } catch (IndexOutOfBoundsException ioobe) {
3398 // Correct result
3399 }
3400 // Check double digit group references
3401 blah = toSupplementaries("zzz123456789101112zzz");
3402 p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)");
3403 m = p.matcher(blah);
3404 result = new StringBuilder();
3405 m.find();
3406 m.appendReplacement(result, toSupplementaries("$1w$11w$3"));
3407 if (!result.toString().equals(toSupplementaries("zzz1w11w3")))
3408 failCount++;
3409
3410 // Check to make sure it backs off $15 to $1 if only three groups
3411 blah = toSupplementaries("zzzabcdcdefzzz");
3412 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)"));
3413 m = p.matcher(blah);
3414 result = new StringBuilder();
3415 m.find();
3416 m.appendReplacement(result, toSupplementaries("$1w$15w$3"));
3417 if (!result.toString().equals(toSupplementaries("zzzabwab5wef")))
3418 failCount++;
3419 // Check nothing has been appended into the output buffer if
3420 // the replacement string triggers IllegalArgumentException.
3421 p = Pattern.compile("(abc)");
3422 m = p.matcher("abcd");
3423 result = new StringBuilder();
3424 m.find();
3425 try {
3426 m.appendReplacement(result, ("xyz$g"));
3427 failCount++;
3428 } catch (IllegalArgumentException iae) {
3429 if (result.length() != 0)
3430 failCount++;
3431 }
3432 report("SB Substitution 2");
3433 }
3434
3435 /*
3436 * 5 groups of characters are created to make a substitution string.
3437 * A base string will be created including random lead chars, the
3438 * substitution string, and random trailing chars.
3439 * A pattern containing the 5 groups is searched for and replaced with:
3440 * random group + random string + random group.
3441 * The results are checked for correctness.
3442 */
3443 private static void substitutionBasher() {
3444 for (int runs = 0; runs<1000; runs++) {
3445 // Create a base string to work in
3446 int leadingChars = generator.nextInt(10);
3447 StringBuffer baseBuffer = new StringBuffer(100);
3448 String leadingString = getRandomAlphaString(leadingChars);
3449 baseBuffer.append(leadingString);
3450
3451 // Create 5 groups of random number of random chars
3452 // Create the string to substitute
3453 // Create the pattern string to search for
3454 StringBuffer bufferToSub = new StringBuffer(25);
3455 StringBuffer bufferToPat = new StringBuffer(50);
3456 String[] groups = new String[5];
3457 for(int i=0; i<5; i++) {
3458 int aGroupSize = generator.nextInt(5)+1;
3459 groups[i] = getRandomAlphaString(aGroupSize);
3460 bufferToSub.append(groups[i]);
3461 bufferToPat.append('(');
3462 bufferToPat.append(groups[i]);
3463 bufferToPat.append(')');
3464 }
3465 String stringToSub = bufferToSub.toString();
3466 String pattern = bufferToPat.toString();
3467
3468 // Place sub string into working string at random index
3469 baseBuffer.append(stringToSub);
3470
3471 // Append random chars to end
3472 int trailingChars = generator.nextInt(10);
3473 String trailingString = getRandomAlphaString(trailingChars);
3474 baseBuffer.append(trailingString);
3475 String baseString = baseBuffer.toString();
3476
3477 // Create test pattern and matcher
3478 Pattern p = Pattern.compile(pattern);
3479 Matcher m = p.matcher(baseString);
3480
3481 // Reject candidate if pattern happens to start early
3482 m.find();
3483 if (m.start() < leadingChars)
3484 continue;
3485
3486 // Reject candidate if more than one match
3487 if (m.find())
3488 continue;
3489
3490 // Construct a replacement string with :
3491 // random group + random string + random group
3492 StringBuffer bufferToRep = new StringBuffer();
3493 int groupIndex1 = generator.nextInt(5);
3494 bufferToRep.append("$" + (groupIndex1 + 1));
3495 String randomMidString = getRandomAlphaString(5);
3496 bufferToRep.append(randomMidString);
3497 int groupIndex2 = generator.nextInt(5);
3498 bufferToRep.append("$" + (groupIndex2 + 1));
3499 String replacement = bufferToRep.toString();
3500
3501 // Do the replacement
3502 String result = m.replaceAll(replacement);
3503
3504 // Construct expected result
3505 StringBuffer bufferToRes = new StringBuffer();
3506 bufferToRes.append(leadingString);
3507 bufferToRes.append(groups[groupIndex1]);
3508 bufferToRes.append(randomMidString);
3509 bufferToRes.append(groups[groupIndex2]);
3510 bufferToRes.append(trailingString);
3511 String expectedResult = bufferToRes.toString();
3512
3513 // Check results
3514 if (!result.equals(expectedResult))
3515 failCount++;
3516 }
3517
3518 report("Substitution Basher");
3519 }
3520
3521 /*
3522 * 5 groups of characters are created to make a substitution string.
3523 * A base string will be created including random lead chars, the
3524 * substitution string, and random trailing chars.
3525 * A pattern containing the 5 groups is searched for and replaced with:
3526 * random group + random string + random group.
3527 * The results are checked for correctness.
3528 */
3529 private static void substitutionBasher2() {
3530 for (int runs = 0; runs<1000; runs++) {
3531 // Create a base string to work in
3532 int leadingChars = generator.nextInt(10);
3533 StringBuilder baseBuffer = new StringBuilder(100);
3534 String leadingString = getRandomAlphaString(leadingChars);
3535 baseBuffer.append(leadingString);
3536
3537 // Create 5 groups of random number of random chars
3538 // Create the string to substitute
3539 // Create the pattern string to search for
3540 StringBuilder bufferToSub = new StringBuilder(25);
3541 StringBuilder bufferToPat = new StringBuilder(50);
3542 String[] groups = new String[5];
3543 for(int i=0; i<5; i++) {
3544 int aGroupSize = generator.nextInt(5)+1;
3545 groups[i] = getRandomAlphaString(aGroupSize);
3546 bufferToSub.append(groups[i]);
3547 bufferToPat.append('(');
3548 bufferToPat.append(groups[i]);
3549 bufferToPat.append(')');
3550 }
3551 String stringToSub = bufferToSub.toString();
3552 String pattern = bufferToPat.toString();
3553
3554 // Place sub string into working string at random index
3555 baseBuffer.append(stringToSub);
3556
3557 // Append random chars to end
3558 int trailingChars = generator.nextInt(10);
3559 String trailingString = getRandomAlphaString(trailingChars);
3560 baseBuffer.append(trailingString);
3561 String baseString = baseBuffer.toString();
3562
3563 // Create test pattern and matcher
3564 Pattern p = Pattern.compile(pattern);
3565 Matcher m = p.matcher(baseString);
3566
3567 // Reject candidate if pattern happens to start early
3568 m.find();
3569 if (m.start() < leadingChars)
3570 continue;
3571
3572 // Reject candidate if more than one match
3573 if (m.find())
3574 continue;
3575
3576 // Construct a replacement string with :
3577 // random group + random string + random group
3578 StringBuilder bufferToRep = new StringBuilder();
3579 int groupIndex1 = generator.nextInt(5);
3580 bufferToRep.append("$" + (groupIndex1 + 1));
3581 String randomMidString = getRandomAlphaString(5);
3582 bufferToRep.append(randomMidString);
3583 int groupIndex2 = generator.nextInt(5);
3584 bufferToRep.append("$" + (groupIndex2 + 1));
3585 String replacement = bufferToRep.toString();
3586
3587 // Do the replacement
3588 String result = m.replaceAll(replacement);
3589
3590 // Construct expected result
3591 StringBuilder bufferToRes = new StringBuilder();
3592 bufferToRes.append(leadingString);
3593 bufferToRes.append(groups[groupIndex1]);
3594 bufferToRes.append(randomMidString);
3595 bufferToRes.append(groups[groupIndex2]);
3596 bufferToRes.append(trailingString);
3597 String expectedResult = bufferToRes.toString();
3598
3599 // Check results
3600 if (!result.equals(expectedResult)) {
3601 failCount++;
3602 }
3603 }
3604
3605 report("Substitution Basher 2");
3606 }
3607
3608 /**
3609 * Checks the handling of some escape sequences that the Pattern
3610 * class should process instead of the java compiler. These are
3611 * not in the file because the escapes should be be processed
3612 * by the Pattern class when the regex is compiled.
3613 */
3614 private static void escapes() throws Exception {
3615 Pattern p = Pattern.compile("\\043");
3616 Matcher m = p.matcher("#");
3617 if (!m.find())
3618 failCount++;
3619
3620 p = Pattern.compile("\\x23");
3621 m = p.matcher("#");
3622 if (!m.find())
3623 failCount++;
3624
3625 p = Pattern.compile("\\u0023");
3626 m = p.matcher("#");
3627 if (!m.find())
3628 failCount++;
3629
3630 report("Escape sequences");
3631 }
3632
3633 /**
3634 * Checks the handling of blank input situations. These
3635 * tests are incompatible with my test file format.
3636 */
3637 private static void blankInput() throws Exception {
3638 Pattern p = Pattern.compile("abc", Pattern.CASE_INSENSITIVE);
3639 Matcher m = p.matcher("");
3640 if (m.find())
3641 failCount++;
3642
3643 p = Pattern.compile("a*", Pattern.CASE_INSENSITIVE);
3644 m = p.matcher("");
3645 if (!m.find())
3646 failCount++;
3647
3648 p = Pattern.compile("abc");
3649 m = p.matcher("");
3650 if (m.find())
3651 failCount++;
3652
3653 p = Pattern.compile("a*");
3654 m = p.matcher("");
3655 if (!m.find())
3656 failCount++;
3657
3658 report("Blank input");
3659 }
3660
3661 /**
3662 * Tests the Boyer-Moore pattern matching of a character sequence
3663 * on randomly generated patterns.
3664 */
3665 private static void bm() throws Exception {
3666 doBnM('a');
3667 report("Boyer Moore (ASCII)");
3668
3669 doBnM(Character.MIN_SUPPLEMENTARY_CODE_POINT - 10);
3670 report("Boyer Moore (Supplementary)");
3671 }
3672
3673 private static void doBnM(int baseCharacter) throws Exception {
3674 int achar=0;
3675
3676 for (int i=0; i<100; i++) {
3677 // Create a short pattern to search for
3678 int patternLength = generator.nextInt(7) + 4;
3679 StringBuffer patternBuffer = new StringBuffer(patternLength);
3680 String pattern;
3681 retry: for (;;) {
3682 for (int x=0; x<patternLength; x++) {
3683 int ch = baseCharacter + generator.nextInt(26);
3684 if (Character.isSupplementaryCodePoint(ch)) {
3685 patternBuffer.append(Character.toChars(ch));
3686 } else {
3687 patternBuffer.append((char)ch);
3688 }
3689 }
3690 pattern = patternBuffer.toString();
3691
3692 // Avoid patterns that start and end with the same substring
3693 // See JDK-6854417
3694 for (int x=1; x < pattern.length(); x++) {
3695 if (pattern.startsWith(pattern.substring(x)))
3696 continue retry;
3697 }
3698 break;
3699 }
3700 Pattern p = Pattern.compile(pattern);
3701
3702 // Create a buffer with random ASCII chars that does
3703 // not match the sample
3704 String toSearch = null;
3705 StringBuffer s = null;
3706 Matcher m = p.matcher("");
3707 do {
3708 s = new StringBuffer(100);
3709 for (int x=0; x<100; x++) {
3710 int ch = baseCharacter + generator.nextInt(26);
3711 if (Character.isSupplementaryCodePoint(ch)) {
3712 s.append(Character.toChars(ch));
3713 } else {
3714 s.append((char)ch);
3715 }
3716 }
3717 toSearch = s.toString();
3718 m.reset(toSearch);
3719 } while (m.find());
3720
3721 // Insert the pattern at a random spot
3722 int insertIndex = generator.nextInt(99);
3723 if (Character.isLowSurrogate(s.charAt(insertIndex)))
3724 insertIndex++;
3725 s = s.insert(insertIndex, pattern);
3726 toSearch = s.toString();
3727
3728 // Make sure that the pattern is found
3729 m.reset(toSearch);
3730 if (!m.find())
3731 failCount++;
3732
3733 // Make sure that the match text is the pattern
3734 if (!m.group().equals(pattern))
3735 failCount++;
3736
3737 // Make sure match occured at insertion point
3738 if (m.start() != insertIndex)
3739 failCount++;
3740 }
3741 }
3742
3743 /**
3744 * Tests the matching of slices on randomly generated patterns.
3745 * The Boyer-Moore optimization is not done on these patterns
3746 * because it uses unicode case folding.
3747 */
3748 private static void slice() throws Exception {
3749 doSlice(Character.MAX_VALUE);
3750 report("Slice");
3751
3752 doSlice(Character.MAX_CODE_POINT);
3753 report("Slice (Supplementary)");
3754 }
3755
3756 private static void doSlice(int maxCharacter) throws Exception {
3757 Random generator = new Random();
3758 int achar=0;
3759
3760 for (int i=0; i<100; i++) {
3761 // Create a short pattern to search for
3762 int patternLength = generator.nextInt(7) + 4;
3763 StringBuffer patternBuffer = new StringBuffer(patternLength);
3764 for (int x=0; x<patternLength; x++) {
3765 int randomChar = 0;
3766 while (!Character.isLetterOrDigit(randomChar))
3767 randomChar = generator.nextInt(maxCharacter);
3768 if (Character.isSupplementaryCodePoint(randomChar)) {
3769 patternBuffer.append(Character.toChars(randomChar));
3770 } else {
3771 patternBuffer.append((char) randomChar);
3772 }
3773 }
3774 String pattern = patternBuffer.toString();
3775 Pattern p = Pattern.compile(pattern, Pattern.UNICODE_CASE);
3776
3777 // Create a buffer with random chars that does not match the sample
3778 String toSearch = null;
3779 StringBuffer s = null;
3780 Matcher m = p.matcher("");
3781 do {
3782 s = new StringBuffer(100);
3783 for (int x=0; x<100; x++) {
3784 int randomChar = 0;
3785 while (!Character.isLetterOrDigit(randomChar))
3786 randomChar = generator.nextInt(maxCharacter);
3787 if (Character.isSupplementaryCodePoint(randomChar)) {
3788 s.append(Character.toChars(randomChar));
3789 } else {
3790 s.append((char) randomChar);
3791 }
3792 }
3793 toSearch = s.toString();
3794 m.reset(toSearch);
3795 } while (m.find());
3796
3797 // Insert the pattern at a random spot
3798 int insertIndex = generator.nextInt(99);
3799 if (Character.isLowSurrogate(s.charAt(insertIndex)))
3800 insertIndex++;
3801 s = s.insert(insertIndex, pattern);
3802 toSearch = s.toString();
3803
3804 // Make sure that the pattern is found
3805 m.reset(toSearch);
3806 if (!m.find())
3807 failCount++;
3808
3809 // Make sure that the match text is the pattern
3810 if (!m.group().equals(pattern))
3811 failCount++;
3812
3813 // Make sure match occured at insertion point
3814 if (m.start() != insertIndex)
3815 failCount++;
3816 }
3817 }
3818
3819 private static void explainFailure(String pattern, String data,
3820 String expected, String actual) {
3821 System.err.println("----------------------------------------");
3822 System.err.println("Pattern = "+pattern);
3823 System.err.println("Data = "+data);
3824 System.err.println("Expected = " + expected);
3825 System.err.println("Actual = " + actual);
3826 }
3827
3828 private static void explainFailure(String pattern, String data,
3829 Throwable t) {
3830 System.err.println("----------------------------------------");
3831 System.err.println("Pattern = "+pattern);
3832 System.err.println("Data = "+data);
3833 t.printStackTrace(System.err);
3834 }
3835
3836 // Testing examples from a file
3837
3838 /**
3839 * Goes through the file "TestCases.txt" and creates many patterns
3840 * described in the file, matching the patterns against input lines in
3841 * the file, and comparing the results against the correct results
3842 * also found in the file. The file format is described in comments
3843 * at the head of the file.
3844 */
3845 private static void processFile(String fileName) throws Exception {
3846 File testCases = new File(System.getProperty("test.src", "."),
3847 fileName);
3848 FileInputStream in = new FileInputStream(testCases);
3849 BufferedReader r = new BufferedReader(new InputStreamReader(in));
3850
3851 // Process next test case.
3852 String aLine;
3853 while((aLine = r.readLine()) != null) {
3854 // Read a line for pattern
3855 String patternString = grabLine(r);
3856 Pattern p = null;
3857 try {
3858 p = compileTestPattern(patternString);
3859 } catch (PatternSyntaxException e) {
3860 String dataString = grabLine(r);
3861 String expectedResult = grabLine(r);
3862 if (expectedResult.startsWith("error"))
3863 continue;
3864 explainFailure(patternString, dataString, e);
3865 failCount++;
3866 continue;
3867 }
3868
3869 // Read a line for input string
3870 String dataString = grabLine(r);
3871 Matcher m = p.matcher(dataString);
3872 StringBuffer result = new StringBuffer();
3873
3874 // Check for IllegalStateExceptions before a match
3875 failCount += preMatchInvariants(m);
3876
3877 boolean found = m.find();
3878
3879 if (found)
3880 failCount += postTrueMatchInvariants(m);
3881 else
3882 failCount += postFalseMatchInvariants(m);
3883
3884 if (found) {
3885 result.append("true ");
3886 result.append(m.group(0) + " ");
3887 } else {
3888 result.append("false ");
3889 }
3890
3891 result.append(m.groupCount());
3892
3893 if (found) {
3894 for (int i=1; i<m.groupCount()+1; i++)
3895 if (m.group(i) != null)
3896 result.append(" " +m.group(i));
3897 }
3898
3899 // Read a line for the expected result
3900 String expectedResult = grabLine(r);
3901
3902 if (!result.toString().equals(expectedResult)) {
3903 explainFailure(patternString, dataString, expectedResult, result.toString());
3904 failCount++;
3905 }
3906 }
3907
3908 report(fileName);
3909 }
3910
3911 private static int preMatchInvariants(Matcher m) {
3912 int failCount = 0;
3913 try {
3914 m.start();
3915 failCount++;
3916 } catch (IllegalStateException ise) {}
3917 try {
3918 m.end();
3919 failCount++;
3920 } catch (IllegalStateException ise) {}
3921 try {
3922 m.group();
3923 failCount++;
3924 } catch (IllegalStateException ise) {}
3925 return failCount;
3926 }
3927
3928 private static int postFalseMatchInvariants(Matcher m) {
3929 int failCount = 0;
3930 try {
3931 m.group();
3932 failCount++;
3933 } catch (IllegalStateException ise) {}
3934 try {
3935 m.start();
3936 failCount++;
3937 } catch (IllegalStateException ise) {}
3938 try {
3939 m.end();
3940 failCount++;
3941 } catch (IllegalStateException ise) {}
3942 return failCount;
3943 }
3944
3945 private static int postTrueMatchInvariants(Matcher m) {
3946 int failCount = 0;
3947 //assert(m.start() = m.start(0);
3948 if (m.start() != m.start(0))
3949 failCount++;
3950 //assert(m.end() = m.end(0);
3951 if (m.start() != m.start(0))
3952 failCount++;
3953 //assert(m.group() = m.group(0);
3954 if (!m.group().equals(m.group(0)))
3955 failCount++;
3956 try {
3957 m.group(50);
3958 failCount++;
3959 } catch (IndexOutOfBoundsException ise) {}
3960
3961 return failCount;
3962 }
3963
3964 private static Pattern compileTestPattern(String patternString) {
3965 if (!patternString.startsWith("'")) {
3966 return Pattern.compile(patternString);
3967 }
3968 int break1 = patternString.lastIndexOf("'");
3969 String flagString = patternString.substring(
3970 break1+1, patternString.length());
3971 patternString = patternString.substring(1, break1);
3972
3973 if (flagString.equals("i"))
3974 return Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
3975
3976 if (flagString.equals("m"))
3977 return Pattern.compile(patternString, Pattern.MULTILINE);
3978
3979 return Pattern.compile(patternString);
3980 }
3981
3982 /**
3983 * Reads a line from the input file. Keeps reading lines until a non
3984 * empty non comment line is read. If the line contains a \n then
3985 * these two characters are replaced by a newline char. If a \\uxxxx
3986 * sequence is read then the sequence is replaced by the unicode char.
3987 */
3988 private static String grabLine(BufferedReader r) throws Exception {
3989 int index = 0;
3990 String line = r.readLine();
3991 while (line.startsWith("//") || line.length() < 1)
3992 line = r.readLine();
3993 while ((index = line.indexOf("\\n")) != -1) {
3994 StringBuffer temp = new StringBuffer(line);
3995 temp.replace(index, index+2, "\n");
3996 line = temp.toString();
3997 }
3998 while ((index = line.indexOf("\\u")) != -1) {
3999 StringBuffer temp = new StringBuffer(line);
4000 String value = temp.substring(index+2, index+6);
4001 char aChar = (char)Integer.parseInt(value, 16);
4002 String unicodeChar = "" + aChar;
4003 temp.replace(index, index+6, unicodeChar);
4004 line = temp.toString();
4005 }
4006
4007 return line;
4008 }
4009
4010 private static void check(Pattern p, String s, String g, String expected) {
4011 Matcher m = p.matcher(s);
4012 m.find();
4013 if (!m.group(g).equals(expected) ||
4014 s.charAt(m.start(g)) != expected.charAt(0) ||
4015 s.charAt(m.end(g) - 1) != expected.charAt(expected.length() - 1))
4016 failCount++;
4017 }
4018
4019 private static void checkReplaceFirst(String p, String s, String r, String expected)
4020 {
4021 if (!expected.equals(Pattern.compile(p)
4022 .matcher(s)
4023 .replaceFirst(r)))
4024 failCount++;
4025 }
4026
4027 private static void checkReplaceAll(String p, String s, String r, String expected)
4028 {
4029 if (!expected.equals(Pattern.compile(p)
4030 .matcher(s)
4031 .replaceAll(r)))
4032 failCount++;
4033 }
4034
4035 private static void checkExpectedFail(String p) {
4036 try {
4037 Pattern.compile(p);
4038 } catch (PatternSyntaxException pse) {
4039 //pse.printStackTrace();
4040 return;
4041 }
4042 failCount++;
4043 }
4044
4045 private static void checkExpectedIAE(Matcher m, String g) {
4046 m.find();
4047 try {
4048 m.group(g);
4049 } catch (IllegalArgumentException x) {
4050 //iae.printStackTrace();
4051 try {
4052 m.start(g);
4053 } catch (IllegalArgumentException xx) {
4054 try {
4055 m.start(g);
4056 } catch (IllegalArgumentException xxx) {
4057 return;
4058 }
4059 }
4060 }
4061 failCount++;
4062 }
4063
4064 private static void checkExpectedNPE(Matcher m) {
4065 m.find();
4066 try {
4067 m.group(null);
4068 } catch (NullPointerException x) {
4069 try {
4070 m.start(null);
4071 } catch (NullPointerException xx) {
4072 try {
4073 m.end(null);
4074 } catch (NullPointerException xxx) {
4075 return;
4076 }
4077 }
4078 }
4079 failCount++;
4080 }
4081
4082 private static void namedGroupCaptureTest() throws Exception {
4083 check(Pattern.compile("x+(?<gname>y+)z+"),
4084 "xxxyyyzzz",
4085 "gname",
4086 "yyy");
4087
4088 check(Pattern.compile("x+(?<gname8>y+)z+"),
4089 "xxxyyyzzz",
4090 "gname8",
4091 "yyy");
4092
4093 //backref
4094 Pattern pattern = Pattern.compile("(a*)bc\\1");
4095 check(pattern, "zzzaabcazzz", true); // found "abca"
4096
4097 check(Pattern.compile("(?<gname>a*)bc\\k<gname>"),
4098 "zzzaabcaazzz", true);
4099
4100 check(Pattern.compile("(?<gname>abc)(def)\\k<gname>"),
4101 "abcdefabc", true);
4102
4103 check(Pattern.compile("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(?<gname>k)\\k<gname>"),
4104 "abcdefghijkk", true);
4105
4106 // Supplementary character tests
4107 check(Pattern.compile("(?<gname>" + toSupplementaries("a*)bc") + "\\k<gname>"),
4108 toSupplementaries("zzzaabcazzz"), true);
4109
4110 check(Pattern.compile("(?<gname>" + toSupplementaries("a*)bc") + "\\k<gname>"),
4111 toSupplementaries("zzzaabcaazzz"), true);
4112
4113 check(Pattern.compile("(?<gname>" + toSupplementaries("abc)(def)") + "\\k<gname>"),
4114 toSupplementaries("abcdefabc"), true);
4115
4116 check(Pattern.compile(toSupplementaries("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)") +
4117 "(?<gname>" +
4118 toSupplementaries("k)") + "\\k<gname>"),
4119 toSupplementaries("abcdefghijkk"), true);
4120
4121 check(Pattern.compile("x+(?<gname>y+)z+\\k<gname>"),
4122 "xxxyyyzzzyyy",
4123 "gname",
4124 "yyy");
4125
4126 //replaceFirst/All
4127 checkReplaceFirst("(?<gn>ab)(c*)",
4128 "abccczzzabcczzzabccc",
4129 "${gn}",
4130 "abzzzabcczzzabccc");
4131
4132 checkReplaceAll("(?<gn>ab)(c*)",
4133 "abccczzzabcczzzabccc",
4134 "${gn}",
4135 "abzzzabzzzab");
4136
4137
4138 checkReplaceFirst("(?<gn>ab)(c*)",
4139 "zzzabccczzzabcczzzabccczzz",
4140 "${gn}",
4141 "zzzabzzzabcczzzabccczzz");
4142
4143 checkReplaceAll("(?<gn>ab)(c*)",
4144 "zzzabccczzzabcczzzabccczzz",
4145 "${gn}",
4146 "zzzabzzzabzzzabzzz");
4147
4148 checkReplaceFirst("(?<gn1>ab)(?<gn2>c*)",
4149 "zzzabccczzzabcczzzabccczzz",
4150 "${gn2}",
4151 "zzzccczzzabcczzzabccczzz");
4152
4153 checkReplaceAll("(?<gn1>ab)(?<gn2>c*)",
4154 "zzzabccczzzabcczzzabccczzz",
4155 "${gn2}",
4156 "zzzccczzzcczzzccczzz");
4157
4158 //toSupplementaries("(ab)(c*)"));
4159 checkReplaceFirst("(?<gn1>" + toSupplementaries("ab") +
4160 ")(?<gn2>" + toSupplementaries("c") + "*)",
4161 toSupplementaries("abccczzzabcczzzabccc"),
4162 "${gn1}",
4163 toSupplementaries("abzzzabcczzzabccc"));
4164
4165
4166 checkReplaceAll("(?<gn1>" + toSupplementaries("ab") +
4167 ")(?<gn2>" + toSupplementaries("c") + "*)",
4168 toSupplementaries("abccczzzabcczzzabccc"),
4169 "${gn1}",
4170 toSupplementaries("abzzzabzzzab"));
4171
4172 checkReplaceFirst("(?<gn1>" + toSupplementaries("ab") +
4173 ")(?<gn2>" + toSupplementaries("c") + "*)",
4174 toSupplementaries("abccczzzabcczzzabccc"),
4175 "${gn2}",
4176 toSupplementaries("ccczzzabcczzzabccc"));
4177
4178
4179 checkReplaceAll("(?<gn1>" + toSupplementaries("ab") +
4180 ")(?<gn2>" + toSupplementaries("c") + "*)",
4181 toSupplementaries("abccczzzabcczzzabccc"),
4182 "${gn2}",
4183 toSupplementaries("ccczzzcczzzccc"));
4184
4185 checkReplaceFirst("(?<dog>Dog)AndCat",
4186 "zzzDogAndCatzzzDogAndCatzzz",
4187 "${dog}",
4188 "zzzDogzzzDogAndCatzzz");
4189
4190
4191 checkReplaceAll("(?<dog>Dog)AndCat",
4192 "zzzDogAndCatzzzDogAndCatzzz",
4193 "${dog}",
4194 "zzzDogzzzDogzzz");
4195
4196 // backref in Matcher & String
4197 if (!"abcdefghij".replaceFirst("cd(?<gn>ef)gh", "${gn}").equals("abefij") ||
4198 !"abbbcbdbefgh".replaceAll("(?<gn>[a-e])b", "${gn}").equals("abcdefgh"))
4199 failCount++;
4200
4201 // negative
4202 checkExpectedFail("(?<groupnamehasnoascii.in>abc)(def)");
4203 checkExpectedFail("(?<groupnamehasnoascii_in>abc)(def)");
4204 checkExpectedFail("(?<6groupnamestartswithdigit>abc)(def)");
4205 checkExpectedFail("(?<gname>abc)(def)\\k<gnameX>");
4206 checkExpectedFail("(?<gname>abc)(?<gname>def)\\k<gnameX>");
4207 checkExpectedIAE(Pattern.compile("(?<gname>abc)(def)").matcher("abcdef"),
4208 "gnameX");
4209 checkExpectedNPE(Pattern.compile("(?<gname>abc)(def)").matcher("abcdef"));
4210 report("NamedGroupCapture");
4211 }
4212
4213 // This is for bug 6919132
4214 private static void nonBmpClassComplementTest() throws Exception {
4215 Pattern p = Pattern.compile("\\P{Lu}");
4216 Matcher m = p.matcher(new String(new int[] {0x1d400}, 0, 1));
4217
4218 if (m.find() && m.start() == 1)
4219 failCount++;
4220
4221 // from a unicode category
4222 p = Pattern.compile("\\P{Lu}");
4223 m = p.matcher(new String(new int[] {0x1d400}, 0, 1));
4224 if (m.find())
4225 failCount++;
4226 if (!m.hitEnd())
4227 failCount++;
4228
4229 // block
4230 p = Pattern.compile("\\P{InMathematicalAlphanumericSymbols}");
4231 m = p.matcher(new String(new int[] {0x1d400}, 0, 1));
4232 if (m.find() && m.start() == 1)
4233 failCount++;
4234
4235 p = Pattern.compile("\\P{sc=GRANTHA}");
4236 m = p.matcher(new String(new int[] {0x11350}, 0, 1));
4237 if (m.find() && m.start() == 1)
4238 failCount++;
4239
4240 report("NonBmpClassComplement");
4241 }
4242
4243 private static void unicodePropertiesTest() throws Exception {
4244 // different forms
4245 if (!Pattern.compile("\\p{IsLu}").matcher("A").matches() ||
4246 !Pattern.compile("\\p{Lu}").matcher("A").matches() ||
4247 !Pattern.compile("\\p{gc=Lu}").matcher("A").matches() ||
4248 !Pattern.compile("\\p{general_category=Lu}").matcher("A").matches() ||
4249 !Pattern.compile("\\p{IsLatin}").matcher("B").matches() ||
4250 !Pattern.compile("\\p{sc=Latin}").matcher("B").matches() ||
4251 !Pattern.compile("\\p{script=Latin}").matcher("B").matches() ||
4252 !Pattern.compile("\\p{InBasicLatin}").matcher("c").matches() ||
4253 !Pattern.compile("\\p{blk=BasicLatin}").matcher("c").matches() ||
4254 !Pattern.compile("\\p{block=BasicLatin}").matcher("c").matches())
4255 failCount++;
4256
4257 Matcher common = Pattern.compile("\\p{script=Common}").matcher("");
4258 Matcher unknown = Pattern.compile("\\p{IsUnknown}").matcher("");
4259 Matcher lastSM = common;
4260 Character.UnicodeScript lastScript = Character.UnicodeScript.of(0);
4261
4262 Matcher latin = Pattern.compile("\\p{block=basic_latin}").matcher("");
4263 Matcher greek = Pattern.compile("\\p{InGreek}").matcher("");
4264 Matcher lastBM = latin;
4265 Character.UnicodeBlock lastBlock = Character.UnicodeBlock.of(0);
4266
4267 for (int cp = 1; cp < Character.MAX_CODE_POINT; cp++) {
4268 if (cp >= 0x30000 && (cp & 0x70) == 0){
4269 continue; // only pick couple code points, they are the same
4270 }
4271
4272 // Unicode Script
4273 Character.UnicodeScript script = Character.UnicodeScript.of(cp);
4274 Matcher m;
4275 String str = new String(Character.toChars(cp));
4276 if (script == lastScript) {
4277 m = lastSM;
4278 m.reset(str);
4279 } else {
4280 m = Pattern.compile("\\p{Is" + script.name() + "}").matcher(str);
4281 }
4282 if (!m.matches()) {
4283 failCount++;
4284 }
4285 Matcher other = (script == Character.UnicodeScript.COMMON)? unknown : common;
4286 other.reset(str);
4287 if (other.matches()) {
4288 failCount++;
4289 }
4290 lastSM = m;
4291 lastScript = script;
4292
4293 // Unicode Block
4294 Character.UnicodeBlock block = Character.UnicodeBlock.of(cp);
4295 if (block == null) {
4296 //System.out.printf("Not a Block: cp=%x%n", cp);
4297 continue;
4298 }
4299 if (block == lastBlock) {
4300 m = lastBM;
4301 m.reset(str);
4302 } else {
4303 m = Pattern.compile("\\p{block=" + block.toString() + "}").matcher(str);
4304 }
4305 if (!m.matches()) {
4306 failCount++;
4307 }
4308 other = (block == Character.UnicodeBlock.BASIC_LATIN)? greek : latin;
4309 other.reset(str);
4310 if (other.matches()) {
4311 failCount++;
4312 }
4313 lastBM = m;
4314 lastBlock = block;
4315 }
4316 report("unicodeProperties");
4317 }
4318
4319 private static void unicodeHexNotationTest() throws Exception {
4320
4321 // negative
4322 checkExpectedFail("\\x{-23}");
4323 checkExpectedFail("\\x{110000}");
4324 checkExpectedFail("\\x{}");
4325 checkExpectedFail("\\x{AB[ef]");
4326
4327 // codepoint
4328 check("^\\x{1033c}$", "\uD800\uDF3C", true);
4329 check("^\\xF0\\x90\\x8C\\xBC$", "\uD800\uDF3C", false);
4330 check("^\\x{D800}\\x{DF3c}+$", "\uD800\uDF3C", false);
4331 check("^\\xF0\\x90\\x8C\\xBC$", "\uD800\uDF3C", false);
4332
4333 // in class
4334 check("^[\\x{D800}\\x{DF3c}]+$", "\uD800\uDF3C", false);
4335 check("^[\\xF0\\x90\\x8C\\xBC]+$", "\uD800\uDF3C", false);
4336 check("^[\\x{D800}\\x{DF3C}]+$", "\uD800\uDF3C", false);
4337 check("^[\\x{DF3C}\\x{D800}]+$", "\uD800\uDF3C", false);
4338 check("^[\\x{D800}\\x{DF3C}]+$", "\uDF3C\uD800", true);
4339 check("^[\\x{DF3C}\\x{D800}]+$", "\uDF3C\uD800", true);
4340
4341 for (int cp = 0; cp <= 0x10FFFF; cp++) {
4342 String s = "A" + new String(Character.toChars(cp)) + "B";
4343 String hexUTF16 = (cp <= 0xFFFF)? String.format("\\u%04x", cp)
4344 : String.format("\\u%04x\\u%04x",
4345 (int) Character.toChars(cp)[0],
4346 (int) Character.toChars(cp)[1]);
4347 String hexCodePoint = "\\x{" + Integer.toHexString(cp) + "}";
4348 if (!Pattern.matches("A" + hexUTF16 + "B", s))
4349 failCount++;
4350 if (!Pattern.matches("A[" + hexUTF16 + "]B", s))
4351 failCount++;
4352 if (!Pattern.matches("A" + hexCodePoint + "B", s))
4353 failCount++;
4354 if (!Pattern.matches("A[" + hexCodePoint + "]B", s))
4355 failCount++;
4356 }
4357 report("unicodeHexNotation");
4358 }
4359
4360 private static void unicodeClassesTest() throws Exception {
4361
4362 Matcher lower = Pattern.compile("\\p{Lower}").matcher("");
4363 Matcher upper = Pattern.compile("\\p{Upper}").matcher("");
4364 Matcher ASCII = Pattern.compile("\\p{ASCII}").matcher("");
4365 Matcher alpha = Pattern.compile("\\p{Alpha}").matcher("");
4366 Matcher digit = Pattern.compile("\\p{Digit}").matcher("");
4367 Matcher alnum = Pattern.compile("\\p{Alnum}").matcher("");
4368 Matcher punct = Pattern.compile("\\p{Punct}").matcher("");
4369 Matcher graph = Pattern.compile("\\p{Graph}").matcher("");
4370 Matcher print = Pattern.compile("\\p{Print}").matcher("");
4371 Matcher blank = Pattern.compile("\\p{Blank}").matcher("");
4372 Matcher cntrl = Pattern.compile("\\p{Cntrl}").matcher("");
4373 Matcher xdigit = Pattern.compile("\\p{XDigit}").matcher("");
4374 Matcher space = Pattern.compile("\\p{Space}").matcher("");
4375 Matcher bound = Pattern.compile("\\b").matcher("");
4376 Matcher word = Pattern.compile("\\w++").matcher("");
4377 // UNICODE_CHARACTER_CLASS
4378 Matcher lowerU = Pattern.compile("\\p{Lower}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4379 Matcher upperU = Pattern.compile("\\p{Upper}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4380 Matcher ASCIIU = Pattern.compile("\\p{ASCII}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4381 Matcher alphaU = Pattern.compile("\\p{Alpha}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4382 Matcher digitU = Pattern.compile("\\p{Digit}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4383 Matcher alnumU = Pattern.compile("\\p{Alnum}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4384 Matcher punctU = Pattern.compile("\\p{Punct}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4385 Matcher graphU = Pattern.compile("\\p{Graph}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4386 Matcher printU = Pattern.compile("\\p{Print}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4387 Matcher blankU = Pattern.compile("\\p{Blank}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4388 Matcher cntrlU = Pattern.compile("\\p{Cntrl}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4389 Matcher xdigitU = Pattern.compile("\\p{XDigit}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4390 Matcher spaceU = Pattern.compile("\\p{Space}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4391 Matcher boundU = Pattern.compile("\\b", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4392 Matcher wordU = Pattern.compile("\\w", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4393 // embedded flag (?U)
4394 Matcher lowerEU = Pattern.compile("(?U)\\p{Lower}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4395 Matcher graphEU = Pattern.compile("(?U)\\p{Graph}", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4396 Matcher wordEU = Pattern.compile("(?U)\\w", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4397
4398 Matcher bwb = Pattern.compile("\\b\\w\\b").matcher("");
4399 Matcher bwbU = Pattern.compile("\\b\\w++\\b", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4400 Matcher bwbEU = Pattern.compile("(?U)\\b\\w++\\b", Pattern.UNICODE_CHARACTER_CLASS).matcher("");
4401 // properties
4402 Matcher lowerP = Pattern.compile("\\p{IsLowerCase}").matcher("");
4403 Matcher upperP = Pattern.compile("\\p{IsUpperCase}").matcher("");
4404 Matcher titleP = Pattern.compile("\\p{IsTitleCase}").matcher("");
4405 Matcher letterP = Pattern.compile("\\p{IsLetter}").matcher("");
4406 Matcher alphaP = Pattern.compile("\\p{IsAlphabetic}").matcher("");
4407 Matcher ideogP = Pattern.compile("\\p{IsIdeographic}").matcher("");
4408 Matcher cntrlP = Pattern.compile("\\p{IsControl}").matcher("");
4409 Matcher spaceP = Pattern.compile("\\p{IsWhiteSpace}").matcher("");
4410 Matcher definedP = Pattern.compile("\\p{IsAssigned}").matcher("");
4411 Matcher nonCCPP = Pattern.compile("\\p{IsNoncharacterCodePoint}").matcher("");
4412 Matcher joinCrtl = Pattern.compile("\\p{IsJoinControl}").matcher("");
4413 // javaMethod
4414 Matcher lowerJ = Pattern.compile("\\p{javaLowerCase}").matcher("");
4415 Matcher upperJ = Pattern.compile("\\p{javaUpperCase}").matcher("");
4416 Matcher alphaJ = Pattern.compile("\\p{javaAlphabetic}").matcher("");
4417 Matcher ideogJ = Pattern.compile("\\p{javaIdeographic}").matcher("");
4418 // GC/C
4419 Matcher gcC = Pattern.compile("\\p{C}").matcher("");
4420
4421 for (int cp = 1; cp < 0x30000; cp++) {
4422 String str = new String(Character.toChars(cp));
4423 int type = Character.getType(cp);
4424 if (// lower
4425 POSIX_ASCII.isLower(cp) != lower.reset(str).matches() ||
4426 Character.isLowerCase(cp) != lowerU.reset(str).matches() ||
4427 Character.isLowerCase(cp) != lowerP.reset(str).matches() ||
4428 Character.isLowerCase(cp) != lowerEU.reset(str).matches()||
4429 Character.isLowerCase(cp) != lowerJ.reset(str).matches()||
4430 // upper
4431 POSIX_ASCII.isUpper(cp) != upper.reset(str).matches() ||
4432 POSIX_Unicode.isUpper(cp) != upperU.reset(str).matches() ||
4433 Character.isUpperCase(cp) != upperP.reset(str).matches() ||
4434 Character.isUpperCase(cp) != upperJ.reset(str).matches() ||
4435 // alpha
4436 POSIX_ASCII.isAlpha(cp) != alpha.reset(str).matches() ||
4437 POSIX_Unicode.isAlpha(cp) != alphaU.reset(str).matches() ||
4438 Character.isAlphabetic(cp)!= alphaP.reset(str).matches() ||
4439 Character.isAlphabetic(cp)!= alphaJ.reset(str).matches() ||
4440 // digit
4441 POSIX_ASCII.isDigit(cp) != digit.reset(str).matches() ||
4442 Character.isDigit(cp) != digitU.reset(str).matches() ||
4443 // alnum
4444 POSIX_ASCII.isAlnum(cp) != alnum.reset(str).matches() ||
4445 POSIX_Unicode.isAlnum(cp) != alnumU.reset(str).matches() ||
4446 // punct
4447 POSIX_ASCII.isPunct(cp) != punct.reset(str).matches() ||
4448 POSIX_Unicode.isPunct(cp) != punctU.reset(str).matches() ||
4449 // graph
4450 POSIX_ASCII.isGraph(cp) != graph.reset(str).matches() ||
4451 POSIX_Unicode.isGraph(cp) != graphU.reset(str).matches() ||
4452 POSIX_Unicode.isGraph(cp) != graphEU.reset(str).matches()||
4453 // blank
4454 POSIX_ASCII.isType(cp, POSIX_ASCII.BLANK)
4455 != blank.reset(str).matches() ||
4456 POSIX_Unicode.isBlank(cp) != blankU.reset(str).matches() ||
4457 // print
4458 POSIX_ASCII.isPrint(cp) != print.reset(str).matches() ||
4459 POSIX_Unicode.isPrint(cp) != printU.reset(str).matches() ||
4460 // cntrl
4461 POSIX_ASCII.isCntrl(cp) != cntrl.reset(str).matches() ||
4462 POSIX_Unicode.isCntrl(cp) != cntrlU.reset(str).matches() ||
4463 (Character.CONTROL == type) != cntrlP.reset(str).matches() ||
4464 // hexdigit
4465 POSIX_ASCII.isHexDigit(cp) != xdigit.reset(str).matches() ||
4466 POSIX_Unicode.isHexDigit(cp) != xdigitU.reset(str).matches() ||
4467 // space
4468 POSIX_ASCII.isSpace(cp) != space.reset(str).matches() ||
4469 POSIX_Unicode.isSpace(cp) != spaceU.reset(str).matches() ||
4470 POSIX_Unicode.isSpace(cp) != spaceP.reset(str).matches() ||
4471 // word
4472 POSIX_ASCII.isWord(cp) != word.reset(str).matches() ||
4473 POSIX_Unicode.isWord(cp) != wordU.reset(str).matches() ||
4474 POSIX_Unicode.isWord(cp) != wordEU.reset(str).matches()||
4475 // bwordb
4476 POSIX_ASCII.isWord(cp) != bwb.reset(str).matches() ||
4477 POSIX_Unicode.isWord(cp) != bwbU.reset(str).matches() ||
4478 // properties
4479 Character.isTitleCase(cp) != titleP.reset(str).matches() ||
4480 Character.isLetter(cp) != letterP.reset(str).matches()||
4481 Character.isIdeographic(cp) != ideogP.reset(str).matches() ||
4482 Character.isIdeographic(cp) != ideogJ.reset(str).matches() ||
4483 (Character.UNASSIGNED == type) == definedP.reset(str).matches() ||
4484 POSIX_Unicode.isNoncharacterCodePoint(cp) != nonCCPP.reset(str).matches() ||
4485 POSIX_Unicode.isJoinControl(cp) != joinCrtl.reset(str).matches() ||
4486 // gc_C
4487 (Character.CONTROL == type || Character.FORMAT == type ||
4488 Character.PRIVATE_USE == type || Character.SURROGATE == type ||
4489 Character.UNASSIGNED == type)
4490 != gcC.reset(str).matches()) {
4491 failCount++;
4492 }
4493 }
4494
4495 // bounds/word align
4496 twoFindIndexes(" \u0180sherman\u0400 ", bound, 1, 10);
4497 if (!bwbU.reset("\u0180sherman\u0400").matches())
4498 failCount++;
4499 twoFindIndexes(" \u0180sh\u0345erman\u0400 ", bound, 1, 11);
4500 if (!bwbU.reset("\u0180sh\u0345erman\u0400").matches())
4501 failCount++;
4502 twoFindIndexes(" \u0724\u0739\u0724 ", bound, 1, 4);
4503 if (!bwbU.reset("\u0724\u0739\u0724").matches())
4504 failCount++;
4505 if (!bwbEU.reset("\u0724\u0739\u0724").matches())
4506 failCount++;
4507 report("unicodePredefinedClasses");
4508 }
4509
4510 private static void unicodeCharacterNameTest() throws Exception {
4511
4512 for (int cp = 0; cp < Character.MAX_CODE_POINT; cp++) {
4513 if (!Character.isValidCodePoint(cp) ||
4514 Character.getType(cp) == Character.UNASSIGNED)
4515 continue;
4516 String str = new String(Character.toChars(cp));
4517 // single
4518 String p = "\\N{" + Character.getName(cp) + "}";
4519 if (!Pattern.compile(p).matcher(str).matches()) {
4520 failCount++;
4521 }
4522 // class[c]
4523 p = "[\\N{" + Character.getName(cp) + "}]";
4524 if (!Pattern.compile(p).matcher(str).matches()) {
4525 failCount++;
4526 }
4527 }
4528
4529 // range
4530 for (int i = 0; i < 10; i++) {
4531 int start = generator.nextInt(20);
4532 int end = start + generator.nextInt(200);
4533 String p = "[\\N{" + Character.getName(start) + "}-\\N{" + Character.getName(end) + "}]";
4534 String str;
4535 for (int cp = start; cp < end; cp++) {
4536 str = new String(Character.toChars(cp));
4537 if (!Pattern.compile(p).matcher(str).matches()) {
4538 failCount++;
4539 }
4540 }
4541 str = new String(Character.toChars(end + 10));
4542 if (Pattern.compile(p).matcher(str).matches()) {
4543 failCount++;
4544 }
4545 }
4546
4547 // slice
4548 for (int i = 0; i < 10; i++) {
4549 int n = generator.nextInt(256);
4550 int[] buf = new int[n];
4551 StringBuffer sb = new StringBuffer(1024);
4552 for (int j = 0; j < n; j++) {
4553 int cp = generator.nextInt(1000);
4554 if (!Character.isValidCodePoint(cp) ||
4555 Character.getType(cp) == Character.UNASSIGNED)
4556 cp = 0x4e00; // just use 4e00
4557 sb.append("\\N{" + Character.getName(cp) + "}");
4558 buf[j] = cp;
4559 }
4560 String p = sb.toString();
4561 String str = new String(buf, 0, buf.length);
4562 if (!Pattern.compile(p).matcher(str).matches()) {
4563 failCount++;
4564 }
4565 }
4566 report("unicodeCharacterName");
4567 }
4568
4569 private static void horizontalAndVerticalWSTest() throws Exception {
4570 String hws = new String (new char[] {
4571 0x09, 0x20, 0xa0, 0x1680, 0x180e,
4572 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005,
4573 0x2006, 0x2007, 0x2008, 0x2009, 0x200a,
4574 0x202f, 0x205f, 0x3000 });
4575 String vws = new String (new char[] {
4576 0x0a, 0x0b, 0x0c, 0x0d, 0x85, 0x2028, 0x2029 });
4577 if (!Pattern.compile("\\h+").matcher(hws).matches() ||
4578 !Pattern.compile("[\\h]+").matcher(hws).matches())
4579 failCount++;
4580 if (Pattern.compile("\\H").matcher(hws).find() ||
4581 Pattern.compile("[\\H]").matcher(hws).find())
4582 failCount++;
4583 if (!Pattern.compile("\\v+").matcher(vws).matches() ||
4584 !Pattern.compile("[\\v]+").matcher(vws).matches())
4585 failCount++;
4586 if (Pattern.compile("\\V").matcher(vws).find() ||
4587 Pattern.compile("[\\V]").matcher(vws).find())
4588 failCount++;
4589 String prefix = "abcd";
4590 String suffix = "efgh";
4591 String ng = "A";
4592 for (int i = 0; i < hws.length(); i++) {
4593 String c = String.valueOf(hws.charAt(i));
4594 Matcher m = Pattern.compile("\\h").matcher(prefix + c + suffix);
4595 if (!m.find() || !c.equals(m.group()))
4596 failCount++;
4597 m = Pattern.compile("[\\h]").matcher(prefix + c + suffix);
4598 if (!m.find() || !c.equals(m.group()))
4599 failCount++;
4600
4601 m = Pattern.compile("\\H").matcher(hws.substring(0, i) + ng + hws.substring(i));
4602 if (!m.find() || !ng.equals(m.group()))
4603 failCount++;
4604 m = Pattern.compile("[\\H]").matcher(hws.substring(0, i) + ng + hws.substring(i));
4605 if (!m.find() || !ng.equals(m.group()))
4606 failCount++;
4607 }
4608 for (int i = 0; i < vws.length(); i++) {
4609 String c = String.valueOf(vws.charAt(i));
4610 Matcher m = Pattern.compile("\\v").matcher(prefix + c + suffix);
4611 if (!m.find() || !c.equals(m.group()))
4612 failCount++;
4613 m = Pattern.compile("[\\v]").matcher(prefix + c + suffix);
4614 if (!m.find() || !c.equals(m.group()))
4615 failCount++;
4616
4617 m = Pattern.compile("\\V").matcher(vws.substring(0, i) + ng + vws.substring(i));
4618 if (!m.find() || !ng.equals(m.group()))
4619 failCount++;
4620 m = Pattern.compile("[\\V]").matcher(vws.substring(0, i) + ng + vws.substring(i));
4621 if (!m.find() || !ng.equals(m.group()))
4622 failCount++;
4623 }
4624 // \v in range is interpreted as 0x0B. This is the undocumented behavior
4625 if (!Pattern.compile("[\\v-\\v]").matcher(String.valueOf((char)0x0B)).matches())
4626 failCount++;
4627 report("horizontalAndVerticalWSTest");
4628 }
4629
4630 private static void linebreakTest() throws Exception {
4631 String linebreaks = new String (new char[] {
4632 0x0A, 0x0B, 0x0C, 0x0D, 0x85, 0x2028, 0x2029 });
4633 String crnl = "\r\n";
4634 if (!(Pattern.compile("\\R+").matcher(linebreaks).matches() &&
4635 Pattern.compile("\\R").matcher(crnl).matches() &&
4636 Pattern.compile("\\Rabc").matcher(crnl + "abc").matches() &&
4637 Pattern.compile("\\Rabc").matcher("\rabc").matches() &&
4638 Pattern.compile("\\R\\R").matcher(crnl).matches() && // backtracking
4639 Pattern.compile("\\R\\n").matcher(crnl).matches()) && // backtracking
4640 !Pattern.compile("((?<!\\R)\\s)*").matcher(crnl).matches()) { // #8176029
4641 failCount++;
4642 }
4643 report("linebreakTest");
4644 }
4645
4646 // #7189363
4647 private static void branchTest() throws Exception {
4648 if (!Pattern.compile("(a)?bc|d").matcher("d").find() || // greedy
4649 !Pattern.compile("(a)+bc|d").matcher("d").find() ||
4650 !Pattern.compile("(a)*bc|d").matcher("d").find() ||
4651 !Pattern.compile("(a)??bc|d").matcher("d").find() || // reluctant
4652 !Pattern.compile("(a)+?bc|d").matcher("d").find() ||
4653 !Pattern.compile("(a)*?bc|d").matcher("d").find() ||
4654 !Pattern.compile("(a)?+bc|d").matcher("d").find() || // possessive
4655 !Pattern.compile("(a)++bc|d").matcher("d").find() ||
4656 !Pattern.compile("(a)*+bc|d").matcher("d").find() ||
4657 !Pattern.compile("(a)?bc|d").matcher("d").matches() || // greedy
4658 !Pattern.compile("(a)+bc|d").matcher("d").matches() ||
4659 !Pattern.compile("(a)*bc|d").matcher("d").matches() ||
4660 !Pattern.compile("(a)??bc|d").matcher("d").matches() || // reluctant
4661 !Pattern.compile("(a)+?bc|d").matcher("d").matches() ||
4662 !Pattern.compile("(a)*?bc|d").matcher("d").matches() ||
4663 !Pattern.compile("(a)?+bc|d").matcher("d").matches() || // possessive
4664 !Pattern.compile("(a)++bc|d").matcher("d").matches() ||
4665 !Pattern.compile("(a)*+bc|d").matcher("d").matches() ||
4666 !Pattern.compile("(a)?bc|de").matcher("de").find() || // others
4667 !Pattern.compile("(a)??bc|de").matcher("de").find() ||
4668 !Pattern.compile("(a)?bc|de").matcher("de").matches() ||
4669 !Pattern.compile("(a)??bc|de").matcher("de").matches())
4670 failCount++;
4671 report("branchTest");
4672 }
4673
4674 // This test is for 8007395
4675 private static void groupCurlyNotFoundSuppTest() throws Exception {
4676 String input = "test this as \ud83d\ude0d";
4677 for (String pStr : new String[] { "test(.)+(@[a-zA-Z.]+)",
4678 "test(.)*(@[a-zA-Z.]+)",
4679 "test([^B])+(@[a-zA-Z.]+)",
4680 "test([^B])*(@[a-zA-Z.]+)",
4681 "test(\\P{IsControl})+(@[a-zA-Z.]+)",
4682 "test(\\P{IsControl})*(@[a-zA-Z.]+)",
4683 }) {
4684 Matcher m = Pattern.compile(pStr, Pattern.CASE_INSENSITIVE)
4685 .matcher(input);
4686 try {
4687 if (m.find()) {
4688 failCount++;
4689 }
4690 } catch (Exception x) {
4691 failCount++;
4692 }
4693 }
4694 report("GroupCurly NotFoundSupp");
4695 }
4696
4697 // This test is for 8023647
4698 private static void groupCurlyBackoffTest() throws Exception {
4699 if (!"abc1c".matches("(\\w)+1\\1") ||
4700 "abc11".matches("(\\w)+1\\1")) {
4701 failCount++;
4702 }
4703 report("GroupCurly backoff");
4704 }
4705
4706 // This test is for 8012646
4707 private static void patternAsPredicate() throws Exception {
4708 Predicate<String> p = Pattern.compile("[a-z]+").asPredicate();
4709
4710 if (p.test("")) {
4711 failCount++;
4712 }
4713 if (!p.test("word")) {
4714 failCount++;
4715 }
4716 if (p.test("1234")) {
4717 failCount++;
4718 }
4719 if (!p.test("word1234")) {
4720 failCount++;
4721 }
4722 report("Pattern.asPredicate");
4723 }
4724
4725 // This test is for 8184692
4726 private static void patternAsMatchPredicate() throws Exception {
4727 Predicate<String> p = Pattern.compile("[a-z]+").asMatchPredicate();
4728
4729 if (p.test("")) {
4730 failCount++;
4731 }
4732 if (!p.test("word")) {
4733 failCount++;
4734 }
4735 if (p.test("1234word")) {
4736 failCount++;
4737 }
4738 if (p.test("1234")) {
4739 failCount++;
4740 }
4741 report("Pattern.asMatchPredicate");
4742 }
4743
4744
4745 // This test is for 8035975
4746 private static void invalidFlags() throws Exception {
4747 for (int flag = 1; flag != 0; flag <<= 1) {
4748 switch (flag) {
4749 case Pattern.CASE_INSENSITIVE:
4750 case Pattern.MULTILINE:
4751 case Pattern.DOTALL:
4752 case Pattern.UNICODE_CASE:
4753 case Pattern.CANON_EQ:
4754 case Pattern.UNIX_LINES:
4755 case Pattern.LITERAL:
4756 case Pattern.UNICODE_CHARACTER_CLASS:
4757 case Pattern.COMMENTS:
4758 // valid flag, continue
4759 break;
4760 default:
4761 try {
4762 Pattern.compile(".", flag);
4763 failCount++;
4764 } catch (IllegalArgumentException expected) {
4765 }
4766 }
4767 }
4768 report("Invalid compile flags");
4769 }
4770
4771 // This test is for 8158482
4772 private static void embeddedFlags() throws Exception {
4773 try {
4774 Pattern.compile("(?i).(?-i).");
4775 Pattern.compile("(?m).(?-m).");
4776 Pattern.compile("(?s).(?-s).");
4777 Pattern.compile("(?d).(?-d).");
4778 Pattern.compile("(?u).(?-u).");
4779 Pattern.compile("(?c).(?-c).");
4780 Pattern.compile("(?x).(?-x).");
4781 Pattern.compile("(?U).(?-U).");
4782 Pattern.compile("(?imsducxU).(?-imsducxU).");
4783 } catch (PatternSyntaxException x) {
4784 failCount++;
4785 }
4786 report("Embedded flags");
4787 }
4788
4789 private static void grapheme() throws Exception {
4790 Files.lines(UCDFiles.GRAPHEME_BREAK_TEST)
4791 .filter( ln -> ln.length() != 0 && !ln.startsWith("#") )
4792 .forEach( ln -> {
4793 ln = ln.replaceAll("\\s+|\\([a-zA-Z]+\\)|\\[[a-zA-Z]]+\\]|#.*", "");
4794 // System.out.println(str);
4795 String[] strs = ln.split("\u00f7|\u00d7");
4796 StringBuilder src = new StringBuilder();
4797 ArrayList<String> graphemes = new ArrayList<>();
4798 StringBuilder buf = new StringBuilder();
4799 int offBk = 0;
4800 for (String str : strs) {
4801 if (str.length() == 0) // first empty str
4802 continue;
4803 int cp = Integer.parseInt(str, 16);
4804 src.appendCodePoint(cp);
4805 buf.appendCodePoint(cp);
4806 offBk += (str.length() + 1);
4807 if (ln.charAt(offBk) == '\u00f7') { // DIV
4808 graphemes.add(buf.toString());
4809 buf = new StringBuilder();
4810 }
4811 }
4812 Pattern p = Pattern.compile("\\X");
4813 Matcher m = p.matcher(src.toString());
4814 Scanner s = new Scanner(src.toString()).useDelimiter("\\b{g}");
4815 for (String g : graphemes) {
4816 // System.out.printf(" grapheme:=[%s]%n", g);
4817 // (1) test \\X directly
4818 if (!m.find() || !m.group().equals(g)) {
4819 System.out.println("Failed \\X [" + ln + "] : " + g);
4820 failCount++;
4821 }
4822 // (2) test \\b{g} + \\X via Scanner
4823 boolean hasNext = s.hasNext(p);
4824 // if (!s.hasNext() || !s.next().equals(next)) {
4825 if (!s.hasNext(p) || !s.next(p).equals(g)) {
4826 System.out.println("Failed b{g} [" + ln + "] : " + g);
4827 failCount++;
4828 }
4829 }
4830 });
4831 // some sanity checks
4832 if (!Pattern.compile("\\X{10}").matcher("abcdefghij").matches() ||
4833 !Pattern.compile("\\b{g}(?:\\X\\b{g}){5}\\b{g}").matcher("abcde").matches() ||
4834 !Pattern.compile("(?:\\X\\b{g}){2}").matcher("\ud800\udc00\ud801\udc02").matches())
4835 failCount++;
4836 // make sure "\b{n}" still works
4837 if (!Pattern.compile("\\b{1}hello\\b{1} \\b{1}world\\b{1}").matcher("hello world").matches())
4838 failCount++;
4839 report("Unicode extended grapheme cluster");
4840 }
4841
4842 // hangup/timeout if go into exponential backtracking
4843 private static void expoBacktracking() throws Exception {
4844
4845 Object[][] patternMatchers = {
4846 // 6328855
4847 { "(.*\n*)*",
4848 "this little fine string lets\r\njava.lang.String.matches\r\ncrash\r\n(We don't know why but adding \r* to the regex makes it work again)",
4849 false },
4850 // 6192895
4851 { " *([a-zA-Z0-9/\\-\\?:\\(\\)\\.,'\\+\\{\\}]+ *)+",
4852 "Hello World this is a test this is a test this is a test A",
4853 true },
4854 { " *([a-zA-Z0-9/\\-\\?:\\(\\)\\.,'\\+\\{\\}]+ *)+",
4855 "Hello World this is a test this is a test this is a test \u4e00 ",
4856 false },
4857 { " *([a-z0-9]+ *)+",
4858 "hello world this is a test this is a test this is a test A",
4859 false },
4860 // 4771934 [FIXED] #5013651?
4861 { "^(\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*(\\.\\w{2,4})+[,;]?)+$",
4862 "abc@efg.abc,efg@abc.abc,abc@xyz.mno;abc@sdfsd.com",
4863 true },
4864 // 4866249 [FIXED]
4865 { "<\\s*" + "(meta|META)" + "(\\s|[^>])+" + "(CHARSET|charset)=" + "(\\s|[^>])+>",
4866 "<META http-equiv=\"Content-Type\" content=\"text/html; charset=ISO-8859-5\">",
4867 true },
4868 { "^(\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*(\\.\\w{2,4})+[,;]?)+$",
4869 "abc@efg.abc,efg@abc.abc,abc@xyz.mno;sdfsd.com",
4870 false },
4871 // 6345469
4872 { "((<[^>]+>)?(((\\s)?)*(\\ )?)*((\\s)?)*)+",
4873 " < br/> < / p> <p> <html> <adfasfdasdf> </p>",
4874 true }, // --> matched
4875 { "((<[^>]+>)?(((\\s)?)*(\\ )?)*((\\s)?)*)+",
4876 " < br/> < / p> <p> <html> <adfasfdasdf> p </p>",
4877 false },
4878 // 5026912
4879 { "^\\s*" + "(\\w|\\d|[\\xC0-\\xFF]|/)+" + "\\s+|$",
4880 "156580451111112225588087755221111111566969655555555",
4881 false},
4882 // 6988218
4883 { "^([+-]?((0[xX](\\p{XDigit}+))|(((\\p{Digit}+)(\\.)?((\\p{Digit}+)?)([eE][+-]?(\\p{Digit}+))?)|(\\.((\\p{Digit}+))([eE][+-]?(\\p{Digit}+))?)))|[n|N]?'([^']*(?:'')*[^']*)*')",
4884 "'%)) order by ANGEBOT.ID",
4885 false}, // find
4886 // 6693451
4887 { "^(\\s*foo\\s*)*$",
4888 "foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo",
4889 true },
4890 { "^(\\s*foo\\s*)*$",
4891 "foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo fo",
4892 false
4893 },
4894 // 7006761
4895 { "(([0-9A-Z]+)([_]?+)*)*", "FOOOOO_BAAAR_FOOOOOOOOO_BA_", true},
4896 { "(([0-9A-Z]+)([_]?+)*)*", "FOOOOO_BAAAR_FOOOOOOOOO_BA_ ", false},
4897 // 8140212
4898 { "(?<before>.*)\\{(?<reflection>\\w+):(?<innerMethod>\\w+(\\.?\\w+(\\(((?<args>(('[^']*')|((/|\\w)+))(,(('[^']*')|((/|\\w)+)))*))?\\))?)*)\\}(?<after>.*)",
4899 "{CeGlobal:getSodCutoff.getGui.getAmqp.getSimpleModeEnabled()",
4900 false
4901 },
4902 { "^(a+)+$", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true},
4903 { "^(a+)+$", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!", false},
4904
4905 { "(x+)*y", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy", true },
4906 { "(x+)*y", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz", false},
4907
4908 { "(x+x+)+y", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy", true},
4909 { "(x+x+)+y", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz", false},
4910
4911 { "(([0-9A-Z]+)([_]?+)*)*", "--------------------------------------", false},
4912
4913 /* not fixed
4914 //8132141 ---> second level exponential backtracking
4915 { "(h|h|ih(((i|a|c|c|a|i|i|j|b|a|i|b|a|a|j))+h)ahbfhba|c|i)*",
4916 "hchcchicihcchciiicichhcichcihcchiihichiciiiihhcchicchhcihchcihiihciichhccciccichcichiihcchcihhicchcciicchcccihiiihhihihihichicihhcciccchihhhcchichchciihiicihciihcccciciccicciiiiiiiiicihhhiiiihchccchchhhhiiihchihcccchhhiiiiiiiicicichicihcciciihichhhhchihciiihhiccccccciciihhichiccchhicchicihihccichicciihcichccihhiciccccccccichhhhihihhcchchihihiihhihihihicichihiiiihhhhihhhchhichiicihhiiiiihchccccchichci" },
4917 */
4918 };
4919
4920 for (Object[] pm : patternMatchers) {
4921 String p = (String)pm[0];
4922 String s = (String)pm[1];
4923 boolean r = (Boolean)pm[2];
4924 if (r != Pattern.compile(p).matcher(s).matches()) {
4925 failCount++;
4926 }
4927 }
4928 }
4929
4930 private static void invalidGroupName() {
4931 // Invalid start of a group name
4932 for (String groupName : List.of("", ".", "0", "\u0040", "\u005b",
4933 "\u0060", "\u007b", "\u0416")) {
4934 for (String pat : List.of("(?<" + groupName + ">)",
4935 "\\k<" + groupName + ">")) {
4936 try {
4937 Pattern.compile(pat);
4938 failCount++;
4939 } catch (PatternSyntaxException e) {
4940 if (!e.getMessage().startsWith(
4941 "capturing group name does not start with a"
4942 + " Latin letter")) {
4943 failCount++;
4944 }
4945 }
4946 }
4947 }
4948 // Invalid char in a group name
4949 for (String groupName : List.of("a.", "b\u0040", "c\u005b",
4950 "d\u0060", "e\u007b", "f\u0416")) {
4951 for (String pat : List.of("(?<" + groupName + ">)",
4952 "\\k<" + groupName + ">")) {
4953 try {
4954 Pattern.compile(pat);
4955 failCount++;
4956 } catch (PatternSyntaxException e) {
4957 if (!e.getMessage().startsWith(
4958 "named capturing group is missing trailing '>'")) {
4959 failCount++;
4960 }
4961 }
4962 }
4963 }
4964 report("Invalid capturing group names");
4965 }
4966
4967 private static void illegalRepetitionRange() {
4968 // huge integers > (2^31 - 1)
4969 String n = BigInteger.valueOf(1L << 32)
4970 .toString();
4971 String m = BigInteger.valueOf(1L << 31)
4972 .add(new BigInteger(80, generator))
4973 .toString();
4974 for (String rep : List.of("", "x", ".", ",", "-1", "2,1",
4975 n, n + ",", "0," + n, n + "," + m, m, m + ",", "0," + m)) {
4976 String pat = ".{" + rep + "}";
4977 try {
4978 Pattern.compile(pat);
4979 failCount++;
4980 System.out.println("Expected to fail. Pattern: " + pat);
4981 } catch (PatternSyntaxException e) {
4982 if (!e.getMessage().startsWith("Illegal repetition")) {
4983 failCount++;
4984 System.out.println("Unexpected error message: " + e.getMessage());
4985 }
4986 } catch (Throwable t) {
4987 failCount++;
4988 System.out.println("Unexpected exception: " + t);
4989 }
4990 }
4991 report("illegalRepetitionRange");
4992 }
4993
4994 private static void surrogatePairWithCanonEq() {
4995 try {
4996 Pattern.compile("\ud834\udd21", Pattern.CANON_EQ);
4997 } catch (Throwable t) {
4998 failCount++;
4999 System.out.println("Unexpected exception: " + t);
5000 }
5001 report("surrogatePairWithCanonEq");
5002 }
5003 }