RegExTest.java revision 8729:0242fce0f717
1/* 2 * Copyright (c) 1999, 2013, 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 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 35 */ 36 37import java.util.regex.*; 38import java.util.Random; 39import java.io.*; 40import java.util.*; 41import java.nio.CharBuffer; 42import java.util.function.Predicate; 43 44/** 45 * This is a test class created to check the operation of 46 * the Pattern and Matcher classes. 47 */ 48public class RegExTest { 49 50 private static Random generator = new Random(); 51 private static boolean failure = false; 52 private static int failCount = 0; 53 private static String firstFailure = null; 54 55 /** 56 * Main to interpret arguments and run several tests. 57 * 58 */ 59 public static void main(String[] args) throws Exception { 60 // Most of the tests are in a file 61 processFile("TestCases.txt"); 62 //processFile("PerlCases.txt"); 63 processFile("BMPTestCases.txt"); 64 processFile("SupplementaryTestCases.txt"); 65 66 // These test many randomly generated char patterns 67 bm(); 68 slice(); 69 70 // These are hard to put into the file 71 escapes(); 72 blankInput(); 73 74 // Substitition tests on randomly generated sequences 75 globalSubstitute(); 76 stringbufferSubstitute(); 77 substitutionBasher(); 78 79 // Canonical Equivalence 80 ceTest(); 81 82 // Anchors 83 anchorTest(); 84 85 // boolean match calls 86 matchesTest(); 87 lookingAtTest(); 88 89 // Pattern API 90 patternMatchesTest(); 91 92 // Misc 93 lookbehindTest(); 94 nullArgumentTest(); 95 backRefTest(); 96 groupCaptureTest(); 97 caretTest(); 98 charClassTest(); 99 emptyPatternTest(); 100 findIntTest(); 101 group0Test(); 102 longPatternTest(); 103 octalTest(); 104 ampersandTest(); 105 negationTest(); 106 splitTest(); 107 appendTest(); 108 caseFoldingTest(); 109 commentsTest(); 110 unixLinesTest(); 111 replaceFirstTest(); 112 gTest(); 113 zTest(); 114 serializeTest(); 115 reluctantRepetitionTest(); 116 multilineDollarTest(); 117 dollarAtEndTest(); 118 caretBetweenTerminatorsTest(); 119 // This RFE rejected in Tiger numOccurrencesTest(); 120 javaCharClassTest(); 121 nonCaptureRepetitionTest(); 122 notCapturedGroupCurlyMatchTest(); 123 escapedSegmentTest(); 124 literalPatternTest(); 125 literalReplacementTest(); 126 regionTest(); 127 toStringTest(); 128 negatedCharClassTest(); 129 findFromTest(); 130 boundsTest(); 131 unicodeWordBoundsTest(); 132 caretAtEndTest(); 133 wordSearchTest(); 134 hitEndTest(); 135 toMatchResultTest(); 136 surrogatesInClassTest(); 137 removeQEQuotingTest(); 138 namedGroupCaptureTest(); 139 nonBmpClassComplementTest(); 140 unicodePropertiesTest(); 141 unicodeHexNotationTest(); 142 unicodeClassesTest(); 143 horizontalAndVerticalWSTest(); 144 linebreakTest(); 145 branchTest(); 146 groupCurlyNotFoundSuppTest(); 147 groupCurlyBackoffTest(); 148 patternAsPredicate(); 149 if (failure) { 150 throw new 151 RuntimeException("RegExTest failed, 1st failure: " + 152 firstFailure); 153 } else { 154 System.err.println("OKAY: All tests passed."); 155 } 156 } 157 158 // Utility functions 159 160 private static String getRandomAlphaString(int length) { 161 StringBuffer buf = new StringBuffer(length); 162 for (int i=0; i<length; i++) { 163 char randChar = (char)(97 + generator.nextInt(26)); 164 buf.append(randChar); 165 } 166 return buf.toString(); 167 } 168 169 private static void check(Matcher m, String expected) { 170 m.find(); 171 if (!m.group().equals(expected)) 172 failCount++; 173 } 174 175 private static void check(Matcher m, String result, boolean expected) { 176 m.find(); 177 if (m.group().equals(result) != expected) 178 failCount++; 179 } 180 181 private static void check(Pattern p, String s, boolean expected) { 182 if (p.matcher(s).find() != expected) 183 failCount++; 184 } 185 186 private static void check(String p, String s, boolean expected) { 187 Matcher matcher = Pattern.compile(p).matcher(s); 188 if (matcher.find() != expected) 189 failCount++; 190 } 191 192 private static void check(String p, char c, boolean expected) { 193 String propertyPattern = expected ? "\\p" + p : "\\P" + p; 194 Pattern pattern = Pattern.compile(propertyPattern); 195 char[] ca = new char[1]; ca[0] = c; 196 Matcher matcher = pattern.matcher(new String(ca)); 197 if (!matcher.find()) 198 failCount++; 199 } 200 201 private static void check(String p, int codePoint, boolean expected) { 202 String propertyPattern = expected ? "\\p" + p : "\\P" + p; 203 Pattern pattern = Pattern.compile(propertyPattern); 204 char[] ca = Character.toChars(codePoint); 205 Matcher matcher = pattern.matcher(new String(ca)); 206 if (!matcher.find()) 207 failCount++; 208 } 209 210 private static void check(String p, int flag, String input, String s, 211 boolean expected) 212 { 213 Pattern pattern = Pattern.compile(p, flag); 214 Matcher matcher = pattern.matcher(input); 215 if (expected) 216 check(matcher, s, expected); 217 else 218 check(pattern, input, false); 219 } 220 221 private static void report(String testName) { 222 int spacesToAdd = 30 - testName.length(); 223 StringBuffer paddedNameBuffer = new StringBuffer(testName); 224 for (int i=0; i<spacesToAdd; i++) 225 paddedNameBuffer.append(" "); 226 String paddedName = paddedNameBuffer.toString(); 227 System.err.println(paddedName + ": " + 228 (failCount==0 ? "Passed":"Failed("+failCount+")")); 229 if (failCount > 0) { 230 failure = true; 231 232 if (firstFailure == null) { 233 firstFailure = testName; 234 } 235 } 236 237 failCount = 0; 238 } 239 240 /** 241 * Converts ASCII alphabet characters [A-Za-z] in the given 's' to 242 * supplementary characters. This method does NOT fully take care 243 * of the regex syntax. 244 */ 245 private static String toSupplementaries(String s) { 246 int length = s.length(); 247 StringBuffer sb = new StringBuffer(length * 2); 248 249 for (int i = 0; i < length; ) { 250 char c = s.charAt(i++); 251 if (c == '\\') { 252 sb.append(c); 253 if (i < length) { 254 c = s.charAt(i++); 255 sb.append(c); 256 if (c == 'u') { 257 // assume no syntax error 258 sb.append(s.charAt(i++)); 259 sb.append(s.charAt(i++)); 260 sb.append(s.charAt(i++)); 261 sb.append(s.charAt(i++)); 262 } 263 } 264 } else if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) { 265 sb.append('\ud800').append((char)('\udc00'+c)); 266 } else { 267 sb.append(c); 268 } 269 } 270 return sb.toString(); 271 } 272 273 // Regular expression tests 274 275 // This is for bug 6178785 276 // Test if an expected NPE gets thrown when passing in a null argument 277 private static boolean check(Runnable test) { 278 try { 279 test.run(); 280 failCount++; 281 return false; 282 } catch (NullPointerException npe) { 283 return true; 284 } 285 } 286 287 private static void nullArgumentTest() { 288 check(new Runnable() { public void run() { Pattern.compile(null); }}); 289 check(new Runnable() { public void run() { Pattern.matches(null, null); }}); 290 check(new Runnable() { public void run() { Pattern.matches("xyz", null);}}); 291 check(new Runnable() { public void run() { Pattern.quote(null);}}); 292 check(new Runnable() { public void run() { Pattern.compile("xyz").split(null);}}); 293 check(new Runnable() { public void run() { Pattern.compile("xyz").matcher(null);}}); 294 295 final Matcher m = Pattern.compile("xyz").matcher("xyz"); 296 m.matches(); 297 check(new Runnable() { public void run() { m.appendTail(null);}}); 298 check(new Runnable() { public void run() { m.replaceAll(null);}}); 299 check(new Runnable() { public void run() { m.replaceFirst(null);}}); 300 check(new Runnable() { public void run() { m.appendReplacement(null, null);}}); 301 check(new Runnable() { public void run() { m.reset(null);}}); 302 check(new Runnable() { public void run() { Matcher.quoteReplacement(null);}}); 303 //check(new Runnable() { public void run() { m.usePattern(null);}}); 304 305 report("Null Argument"); 306 } 307 308 // This is for bug6635133 309 // Test if surrogate pair in Unicode escapes can be handled correctly. 310 private static void surrogatesInClassTest() throws Exception { 311 Pattern pattern = Pattern.compile("[\\ud834\\udd21-\\ud834\\udd24]"); 312 Matcher matcher = pattern.matcher("\ud834\udd22"); 313 if (!matcher.find()) 314 failCount++; 315 316 report("Surrogate pair in Unicode escape"); 317 } 318 319 // This is for bug6990617 320 // Test if Pattern.RemoveQEQuoting works correctly if the octal unicode 321 // char encoding is only 2 or 3 digits instead of 4 and the first quoted 322 // char is an octal digit. 323 private static void removeQEQuotingTest() throws Exception { 324 Pattern pattern = 325 Pattern.compile("\\011\\Q1sometext\\E\\011\\Q2sometext\\E"); 326 Matcher matcher = pattern.matcher("\t1sometext\t2sometext"); 327 if (!matcher.find()) 328 failCount++; 329 330 report("Remove Q/E Quoting"); 331 } 332 333 // This is for bug 4988891 334 // Test toMatchResult to see that it is a copy of the Matcher 335 // that is not affected by subsequent operations on the original 336 private static void toMatchResultTest() throws Exception { 337 Pattern pattern = Pattern.compile("squid"); 338 Matcher matcher = pattern.matcher( 339 "agiantsquidofdestinyasmallsquidoffate"); 340 matcher.find(); 341 int matcherStart1 = matcher.start(); 342 MatchResult mr = matcher.toMatchResult(); 343 if (mr == matcher) 344 failCount++; 345 int resultStart1 = mr.start(); 346 if (matcherStart1 != resultStart1) 347 failCount++; 348 matcher.find(); 349 int matcherStart2 = matcher.start(); 350 int resultStart2 = mr.start(); 351 if (matcherStart2 == resultStart2) 352 failCount++; 353 if (resultStart1 != resultStart2) 354 failCount++; 355 MatchResult mr2 = matcher.toMatchResult(); 356 if (mr == mr2) 357 failCount++; 358 if (mr2.start() != matcherStart2) 359 failCount++; 360 report("toMatchResult is a copy"); 361 } 362 363 // This is for bug 5013885 364 // Must test a slice to see if it reports hitEnd correctly 365 private static void hitEndTest() throws Exception { 366 // Basic test of Slice node 367 Pattern p = Pattern.compile("^squidattack"); 368 Matcher m = p.matcher("squack"); 369 m.find(); 370 if (m.hitEnd()) 371 failCount++; 372 m.reset("squid"); 373 m.find(); 374 if (!m.hitEnd()) 375 failCount++; 376 377 // Test Slice, SliceA and SliceU nodes 378 for (int i=0; i<3; i++) { 379 int flags = 0; 380 if (i==1) flags = Pattern.CASE_INSENSITIVE; 381 if (i==2) flags = Pattern.UNICODE_CASE; 382 p = Pattern.compile("^abc", flags); 383 m = p.matcher("ad"); 384 m.find(); 385 if (m.hitEnd()) 386 failCount++; 387 m.reset("ab"); 388 m.find(); 389 if (!m.hitEnd()) 390 failCount++; 391 } 392 393 // Test Boyer-Moore node 394 p = Pattern.compile("catattack"); 395 m = p.matcher("attack"); 396 m.find(); 397 if (!m.hitEnd()) 398 failCount++; 399 400 p = Pattern.compile("catattack"); 401 m = p.matcher("attackattackattackcatatta"); 402 m.find(); 403 if (!m.hitEnd()) 404 failCount++; 405 report("hitEnd from a Slice"); 406 } 407 408 // This is for bug 4997476 409 // It is weird code submitted by customer demonstrating a regression 410 private static void wordSearchTest() throws Exception { 411 String testString = new String("word1 word2 word3"); 412 Pattern p = Pattern.compile("\\b"); 413 Matcher m = p.matcher(testString); 414 int position = 0; 415 int start = 0; 416 while (m.find(position)) { 417 start = m.start(); 418 if (start == testString.length()) 419 break; 420 if (m.find(start+1)) { 421 position = m.start(); 422 } else { 423 position = testString.length(); 424 } 425 if (testString.substring(start, position).equals(" ")) 426 continue; 427 if (!testString.substring(start, position-1).startsWith("word")) 428 failCount++; 429 } 430 report("Customer word search"); 431 } 432 433 // This is for bug 4994840 434 private static void caretAtEndTest() throws Exception { 435 // Problem only occurs with multiline patterns 436 // containing a beginning-of-line caret "^" followed 437 // by an expression that also matches the empty string. 438 Pattern pattern = Pattern.compile("^x?", Pattern.MULTILINE); 439 Matcher matcher = pattern.matcher("\r"); 440 matcher.find(); 441 matcher.find(); 442 report("Caret at end"); 443 } 444 445 // This test is for 4979006 446 // Check to see if word boundary construct properly handles unicode 447 // non spacing marks 448 private static void unicodeWordBoundsTest() throws Exception { 449 String spaces = " "; 450 String wordChar = "a"; 451 String nsm = "\u030a"; 452 453 assert (Character.getType('\u030a') == Character.NON_SPACING_MARK); 454 455 Pattern pattern = Pattern.compile("\\b"); 456 Matcher matcher = pattern.matcher(""); 457 // S=other B=word character N=non spacing mark .=word boundary 458 // SS.BB.SS 459 String input = spaces + wordChar + wordChar + spaces; 460 twoFindIndexes(input, matcher, 2, 4); 461 // SS.BBN.SS 462 input = spaces + wordChar +wordChar + nsm + spaces; 463 twoFindIndexes(input, matcher, 2, 5); 464 // SS.BN.SS 465 input = spaces + wordChar + nsm + spaces; 466 twoFindIndexes(input, matcher, 2, 4); 467 // SS.BNN.SS 468 input = spaces + wordChar + nsm + nsm + spaces; 469 twoFindIndexes(input, matcher, 2, 5); 470 // SSN.BB.SS 471 input = spaces + nsm + wordChar + wordChar + spaces; 472 twoFindIndexes(input, matcher, 3, 5); 473 // SS.BNB.SS 474 input = spaces + wordChar + nsm + wordChar + spaces; 475 twoFindIndexes(input, matcher, 2, 5); 476 // SSNNSS 477 input = spaces + nsm + nsm + spaces; 478 matcher.reset(input); 479 if (matcher.find()) 480 failCount++; 481 // SSN.BBN.SS 482 input = spaces + nsm + wordChar + wordChar + nsm + spaces; 483 twoFindIndexes(input, matcher, 3, 6); 484 485 report("Unicode word boundary"); 486 } 487 488 private static void twoFindIndexes(String input, Matcher matcher, int a, 489 int b) throws Exception 490 { 491 matcher.reset(input); 492 matcher.find(); 493 if (matcher.start() != a) 494 failCount++; 495 matcher.find(); 496 if (matcher.start() != b) 497 failCount++; 498 } 499 500 // This test is for 6284152 501 static void check(String regex, String input, String[] expected) { 502 List<String> result = new ArrayList<String>(); 503 Pattern p = Pattern.compile(regex); 504 Matcher m = p.matcher(input); 505 while (m.find()) { 506 result.add(m.group()); 507 } 508 if (!Arrays.asList(expected).equals(result)) 509 failCount++; 510 } 511 512 private static void lookbehindTest() throws Exception { 513 //Positive 514 check("(?<=%.{0,5})foo\\d", 515 "%foo1\n%bar foo2\n%bar foo3\n%blahblah foo4\nfoo5", 516 new String[]{"foo1", "foo2", "foo3"}); 517 518 //boundary at end of the lookbehind sub-regex should work consistently 519 //with the boundary just after the lookbehind sub-regex 520 check("(?<=.*\\b)foo", "abcd foo", new String[]{"foo"}); 521 check("(?<=.*)\\bfoo", "abcd foo", new String[]{"foo"}); 522 check("(?<!abc )\\bfoo", "abc foo", new String[0]); 523 check("(?<!abc \\b)foo", "abc foo", new String[0]); 524 525 //Negative 526 check("(?<!%.{0,5})foo\\d", 527 "%foo1\n%bar foo2\n%bar foo3\n%blahblah foo4\nfoo5", 528 new String[] {"foo4", "foo5"}); 529 530 //Positive greedy 531 check("(?<=%b{1,4})foo", "%bbbbfoo", new String[] {"foo"}); 532 533 //Positive reluctant 534 check("(?<=%b{1,4}?)foo", "%bbbbfoo", new String[] {"foo"}); 535 536 //supplementary 537 check("(?<=%b{1,4})fo\ud800\udc00o", "%bbbbfo\ud800\udc00o", 538 new String[] {"fo\ud800\udc00o"}); 539 check("(?<=%b{1,4}?)fo\ud800\udc00o", "%bbbbfo\ud800\udc00o", 540 new String[] {"fo\ud800\udc00o"}); 541 check("(?<!%b{1,4})fo\ud800\udc00o", "%afo\ud800\udc00o", 542 new String[] {"fo\ud800\udc00o"}); 543 check("(?<!%b{1,4}?)fo\ud800\udc00o", "%afo\ud800\udc00o", 544 new String[] {"fo\ud800\udc00o"}); 545 report("Lookbehind"); 546 } 547 548 // This test is for 4938995 549 // Check to see if weak region boundaries are transparent to 550 // lookahead and lookbehind constructs 551 private static void boundsTest() throws Exception { 552 String fullMessage = "catdogcat"; 553 Pattern pattern = Pattern.compile("(?<=cat)dog(?=cat)"); 554 Matcher matcher = pattern.matcher("catdogca"); 555 matcher.useTransparentBounds(true); 556 if (matcher.find()) 557 failCount++; 558 matcher.reset("atdogcat"); 559 if (matcher.find()) 560 failCount++; 561 matcher.reset(fullMessage); 562 if (!matcher.find()) 563 failCount++; 564 matcher.reset(fullMessage); 565 matcher.region(0,9); 566 if (!matcher.find()) 567 failCount++; 568 matcher.reset(fullMessage); 569 matcher.region(0,6); 570 if (!matcher.find()) 571 failCount++; 572 matcher.reset(fullMessage); 573 matcher.region(3,6); 574 if (!matcher.find()) 575 failCount++; 576 matcher.useTransparentBounds(false); 577 if (matcher.find()) 578 failCount++; 579 580 // Negative lookahead/lookbehind 581 pattern = Pattern.compile("(?<!cat)dog(?!cat)"); 582 matcher = pattern.matcher("dogcat"); 583 matcher.useTransparentBounds(true); 584 matcher.region(0,3); 585 if (matcher.find()) 586 failCount++; 587 matcher.reset("catdog"); 588 matcher.region(3,6); 589 if (matcher.find()) 590 failCount++; 591 matcher.useTransparentBounds(false); 592 matcher.reset("dogcat"); 593 matcher.region(0,3); 594 if (!matcher.find()) 595 failCount++; 596 matcher.reset("catdog"); 597 matcher.region(3,6); 598 if (!matcher.find()) 599 failCount++; 600 601 report("Region bounds transparency"); 602 } 603 604 // This test is for 4945394 605 private static void findFromTest() throws Exception { 606 String message = "This is 40 $0 message."; 607 Pattern pat = Pattern.compile("\\$0"); 608 Matcher match = pat.matcher(message); 609 if (!match.find()) 610 failCount++; 611 if (match.find()) 612 failCount++; 613 if (match.find()) 614 failCount++; 615 report("Check for alternating find"); 616 } 617 618 // This test is for 4872664 and 4892980 619 private static void negatedCharClassTest() throws Exception { 620 Pattern pattern = Pattern.compile("[^>]"); 621 Matcher matcher = pattern.matcher("\u203A"); 622 if (!matcher.matches()) 623 failCount++; 624 pattern = Pattern.compile("[^fr]"); 625 matcher = pattern.matcher("a"); 626 if (!matcher.find()) 627 failCount++; 628 matcher.reset("\u203A"); 629 if (!matcher.find()) 630 failCount++; 631 String s = "for"; 632 String result[] = s.split("[^fr]"); 633 if (!result[0].equals("f")) 634 failCount++; 635 if (!result[1].equals("r")) 636 failCount++; 637 s = "f\u203Ar"; 638 result = s.split("[^fr]"); 639 if (!result[0].equals("f")) 640 failCount++; 641 if (!result[1].equals("r")) 642 failCount++; 643 644 // Test adding to bits, subtracting a node, then adding to bits again 645 pattern = Pattern.compile("[^f\u203Ar]"); 646 matcher = pattern.matcher("a"); 647 if (!matcher.find()) 648 failCount++; 649 matcher.reset("f"); 650 if (matcher.find()) 651 failCount++; 652 matcher.reset("\u203A"); 653 if (matcher.find()) 654 failCount++; 655 matcher.reset("r"); 656 if (matcher.find()) 657 failCount++; 658 matcher.reset("\u203B"); 659 if (!matcher.find()) 660 failCount++; 661 662 // Test subtracting a node, adding to bits, subtracting again 663 pattern = Pattern.compile("[^\u203Ar\u203B]"); 664 matcher = pattern.matcher("a"); 665 if (!matcher.find()) 666 failCount++; 667 matcher.reset("\u203A"); 668 if (matcher.find()) 669 failCount++; 670 matcher.reset("r"); 671 if (matcher.find()) 672 failCount++; 673 matcher.reset("\u203B"); 674 if (matcher.find()) 675 failCount++; 676 matcher.reset("\u203C"); 677 if (!matcher.find()) 678 failCount++; 679 680 report("Negated Character Class"); 681 } 682 683 // This test is for 4628291 684 private static void toStringTest() throws Exception { 685 Pattern pattern = Pattern.compile("b+"); 686 if (pattern.toString() != "b+") 687 failCount++; 688 Matcher matcher = pattern.matcher("aaabbbccc"); 689 String matcherString = matcher.toString(); // unspecified 690 matcher.find(); 691 matcherString = matcher.toString(); // unspecified 692 matcher.region(0,3); 693 matcherString = matcher.toString(); // unspecified 694 matcher.reset(); 695 matcherString = matcher.toString(); // unspecified 696 report("toString"); 697 } 698 699 // This test is for 4808962 700 private static void literalPatternTest() throws Exception { 701 int flags = Pattern.LITERAL; 702 703 Pattern pattern = Pattern.compile("abc\\t$^", flags); 704 check(pattern, "abc\\t$^", true); 705 706 pattern = Pattern.compile(Pattern.quote("abc\\t$^")); 707 check(pattern, "abc\\t$^", true); 708 709 pattern = Pattern.compile("\\Qa^$bcabc\\E", flags); 710 check(pattern, "\\Qa^$bcabc\\E", true); 711 check(pattern, "a^$bcabc", false); 712 713 pattern = Pattern.compile("\\\\Q\\\\E"); 714 check(pattern, "\\Q\\E", true); 715 716 pattern = Pattern.compile("\\Qabc\\Eefg\\\\Q\\\\Ehij"); 717 check(pattern, "abcefg\\Q\\Ehij", true); 718 719 pattern = Pattern.compile("\\\\\\Q\\\\E"); 720 check(pattern, "\\\\\\\\", true); 721 722 pattern = Pattern.compile(Pattern.quote("\\Qa^$bcabc\\E")); 723 check(pattern, "\\Qa^$bcabc\\E", true); 724 check(pattern, "a^$bcabc", false); 725 726 pattern = Pattern.compile(Pattern.quote("\\Qabc\\Edef")); 727 check(pattern, "\\Qabc\\Edef", true); 728 check(pattern, "abcdef", false); 729 730 pattern = Pattern.compile(Pattern.quote("abc\\Edef")); 731 check(pattern, "abc\\Edef", true); 732 check(pattern, "abcdef", false); 733 734 pattern = Pattern.compile(Pattern.quote("\\E")); 735 check(pattern, "\\E", true); 736 737 pattern = Pattern.compile("((((abc.+?:)", flags); 738 check(pattern, "((((abc.+?:)", true); 739 740 flags |= Pattern.MULTILINE; 741 742 pattern = Pattern.compile("^cat$", flags); 743 check(pattern, "abc^cat$def", true); 744 check(pattern, "cat", false); 745 746 flags |= Pattern.CASE_INSENSITIVE; 747 748 pattern = Pattern.compile("abcdef", flags); 749 check(pattern, "ABCDEF", true); 750 check(pattern, "AbCdEf", true); 751 752 flags |= Pattern.DOTALL; 753 754 pattern = Pattern.compile("a...b", flags); 755 check(pattern, "A...b", true); 756 check(pattern, "Axxxb", false); 757 758 flags |= Pattern.CANON_EQ; 759 760 Pattern p = Pattern.compile("testa\u030a", flags); 761 check(pattern, "testa\u030a", false); 762 check(pattern, "test\u00e5", false); 763 764 // Supplementary character test 765 flags = Pattern.LITERAL; 766 767 pattern = Pattern.compile(toSupplementaries("abc\\t$^"), flags); 768 check(pattern, toSupplementaries("abc\\t$^"), true); 769 770 pattern = Pattern.compile(Pattern.quote(toSupplementaries("abc\\t$^"))); 771 check(pattern, toSupplementaries("abc\\t$^"), true); 772 773 pattern = Pattern.compile(toSupplementaries("\\Qa^$bcabc\\E"), flags); 774 check(pattern, toSupplementaries("\\Qa^$bcabc\\E"), true); 775 check(pattern, toSupplementaries("a^$bcabc"), false); 776 777 pattern = Pattern.compile(Pattern.quote(toSupplementaries("\\Qa^$bcabc\\E"))); 778 check(pattern, toSupplementaries("\\Qa^$bcabc\\E"), true); 779 check(pattern, toSupplementaries("a^$bcabc"), false); 780 781 pattern = Pattern.compile(Pattern.quote(toSupplementaries("\\Qabc\\Edef"))); 782 check(pattern, toSupplementaries("\\Qabc\\Edef"), true); 783 check(pattern, toSupplementaries("abcdef"), false); 784 785 pattern = Pattern.compile(Pattern.quote(toSupplementaries("abc\\Edef"))); 786 check(pattern, toSupplementaries("abc\\Edef"), true); 787 check(pattern, toSupplementaries("abcdef"), false); 788 789 pattern = Pattern.compile(toSupplementaries("((((abc.+?:)"), flags); 790 check(pattern, toSupplementaries("((((abc.+?:)"), true); 791 792 flags |= Pattern.MULTILINE; 793 794 pattern = Pattern.compile(toSupplementaries("^cat$"), flags); 795 check(pattern, toSupplementaries("abc^cat$def"), true); 796 check(pattern, toSupplementaries("cat"), false); 797 798 flags |= Pattern.DOTALL; 799 800 // note: this is case-sensitive. 801 pattern = Pattern.compile(toSupplementaries("a...b"), flags); 802 check(pattern, toSupplementaries("a...b"), true); 803 check(pattern, toSupplementaries("axxxb"), false); 804 805 flags |= Pattern.CANON_EQ; 806 807 String t = toSupplementaries("test"); 808 p = Pattern.compile(t + "a\u030a", flags); 809 check(pattern, t + "a\u030a", false); 810 check(pattern, t + "\u00e5", false); 811 812 report("Literal pattern"); 813 } 814 815 // This test is for 4803179 816 // This test is also for 4808962, replacement parts 817 private static void literalReplacementTest() throws Exception { 818 int flags = Pattern.LITERAL; 819 820 Pattern pattern = Pattern.compile("abc", flags); 821 Matcher matcher = pattern.matcher("zzzabczzz"); 822 String replaceTest = "$0"; 823 String result = matcher.replaceAll(replaceTest); 824 if (!result.equals("zzzabczzz")) 825 failCount++; 826 827 matcher.reset(); 828 String literalReplacement = matcher.quoteReplacement(replaceTest); 829 result = matcher.replaceAll(literalReplacement); 830 if (!result.equals("zzz$0zzz")) 831 failCount++; 832 833 matcher.reset(); 834 replaceTest = "\\t$\\$"; 835 literalReplacement = matcher.quoteReplacement(replaceTest); 836 result = matcher.replaceAll(literalReplacement); 837 if (!result.equals("zzz\\t$\\$zzz")) 838 failCount++; 839 840 // Supplementary character test 841 pattern = Pattern.compile(toSupplementaries("abc"), flags); 842 matcher = pattern.matcher(toSupplementaries("zzzabczzz")); 843 replaceTest = "$0"; 844 result = matcher.replaceAll(replaceTest); 845 if (!result.equals(toSupplementaries("zzzabczzz"))) 846 failCount++; 847 848 matcher.reset(); 849 literalReplacement = matcher.quoteReplacement(replaceTest); 850 result = matcher.replaceAll(literalReplacement); 851 if (!result.equals(toSupplementaries("zzz$0zzz"))) 852 failCount++; 853 854 matcher.reset(); 855 replaceTest = "\\t$\\$"; 856 literalReplacement = matcher.quoteReplacement(replaceTest); 857 result = matcher.replaceAll(literalReplacement); 858 if (!result.equals(toSupplementaries("zzz\\t$\\$zzz"))) 859 failCount++; 860 861 // IAE should be thrown if backslash or '$' is the last character 862 // in replacement string 863 try { 864 "\uac00".replaceAll("\uac00", "$"); 865 failCount++; 866 } catch (IllegalArgumentException iie) { 867 } catch (Exception e) { 868 failCount++; 869 } 870 try { 871 "\uac00".replaceAll("\uac00", "\\"); 872 failCount++; 873 } catch (IllegalArgumentException iie) { 874 } catch (Exception e) { 875 failCount++; 876 } 877 report("Literal replacement"); 878 } 879 880 // This test is for 4757029 881 private static void regionTest() throws Exception { 882 Pattern pattern = Pattern.compile("abc"); 883 Matcher matcher = pattern.matcher("abcdefabc"); 884 885 matcher.region(0,9); 886 if (!matcher.find()) 887 failCount++; 888 if (!matcher.find()) 889 failCount++; 890 matcher.region(0,3); 891 if (!matcher.find()) 892 failCount++; 893 matcher.region(3,6); 894 if (matcher.find()) 895 failCount++; 896 matcher.region(0,2); 897 if (matcher.find()) 898 failCount++; 899 900 expectRegionFail(matcher, 1, -1); 901 expectRegionFail(matcher, -1, -1); 902 expectRegionFail(matcher, -1, 1); 903 expectRegionFail(matcher, 5, 3); 904 expectRegionFail(matcher, 5, 12); 905 expectRegionFail(matcher, 12, 12); 906 907 pattern = Pattern.compile("^abc$"); 908 matcher = pattern.matcher("zzzabczzz"); 909 matcher.region(0,9); 910 if (matcher.find()) 911 failCount++; 912 matcher.region(3,6); 913 if (!matcher.find()) 914 failCount++; 915 matcher.region(3,6); 916 matcher.useAnchoringBounds(false); 917 if (matcher.find()) 918 failCount++; 919 920 // Supplementary character test 921 pattern = Pattern.compile(toSupplementaries("abc")); 922 matcher = pattern.matcher(toSupplementaries("abcdefabc")); 923 matcher.region(0,9*2); 924 if (!matcher.find()) 925 failCount++; 926 if (!matcher.find()) 927 failCount++; 928 matcher.region(0,3*2); 929 if (!matcher.find()) 930 failCount++; 931 matcher.region(1,3*2); 932 if (matcher.find()) 933 failCount++; 934 matcher.region(3*2,6*2); 935 if (matcher.find()) 936 failCount++; 937 matcher.region(0,2*2); 938 if (matcher.find()) 939 failCount++; 940 matcher.region(0,2*2+1); 941 if (matcher.find()) 942 failCount++; 943 944 expectRegionFail(matcher, 1*2, -1); 945 expectRegionFail(matcher, -1, -1); 946 expectRegionFail(matcher, -1, 1*2); 947 expectRegionFail(matcher, 5*2, 3*2); 948 expectRegionFail(matcher, 5*2, 12*2); 949 expectRegionFail(matcher, 12*2, 12*2); 950 951 pattern = Pattern.compile(toSupplementaries("^abc$")); 952 matcher = pattern.matcher(toSupplementaries("zzzabczzz")); 953 matcher.region(0,9*2); 954 if (matcher.find()) 955 failCount++; 956 matcher.region(3*2,6*2); 957 if (!matcher.find()) 958 failCount++; 959 matcher.region(3*2+1,6*2); 960 if (matcher.find()) 961 failCount++; 962 matcher.region(3*2,6*2-1); 963 if (matcher.find()) 964 failCount++; 965 matcher.region(3*2,6*2); 966 matcher.useAnchoringBounds(false); 967 if (matcher.find()) 968 failCount++; 969 report("Regions"); 970 } 971 972 private static void expectRegionFail(Matcher matcher, int index1, 973 int index2) 974 { 975 try { 976 matcher.region(index1, index2); 977 failCount++; 978 } catch (IndexOutOfBoundsException ioobe) { 979 // Correct result 980 } catch (IllegalStateException ise) { 981 // Correct result 982 } 983 } 984 985 // This test is for 4803197 986 private static void escapedSegmentTest() throws Exception { 987 988 Pattern pattern = Pattern.compile("\\Qdir1\\dir2\\E"); 989 check(pattern, "dir1\\dir2", true); 990 991 pattern = Pattern.compile("\\Qdir1\\dir2\\\\E"); 992 check(pattern, "dir1\\dir2\\", true); 993 994 pattern = Pattern.compile("(\\Qdir1\\dir2\\\\E)"); 995 check(pattern, "dir1\\dir2\\", true); 996 997 // Supplementary character test 998 pattern = Pattern.compile(toSupplementaries("\\Qdir1\\dir2\\E")); 999 check(pattern, toSupplementaries("dir1\\dir2"), true); 1000 1001 pattern = Pattern.compile(toSupplementaries("\\Qdir1\\dir2")+"\\\\E"); 1002 check(pattern, toSupplementaries("dir1\\dir2\\"), true); 1003 1004 pattern = Pattern.compile(toSupplementaries("(\\Qdir1\\dir2")+"\\\\E)"); 1005 check(pattern, toSupplementaries("dir1\\dir2\\"), true); 1006 1007 report("Escaped segment"); 1008 } 1009 1010 // This test is for 4792284 1011 private static void nonCaptureRepetitionTest() throws Exception { 1012 String input = "abcdefgh;"; 1013 1014 String[] patterns = new String[] { 1015 "(?:\\w{4})+;", 1016 "(?:\\w{8})*;", 1017 "(?:\\w{2}){2,4};", 1018 "(?:\\w{4}){2,};", // only matches the 1019 ".*?(?:\\w{5})+;", // specified minimum 1020 ".*?(?:\\w{9})*;", // number of reps - OK 1021 "(?:\\w{4})+?;", // lazy repetition - OK 1022 "(?:\\w{4})++;", // possessive repetition - OK 1023 "(?:\\w{2,}?)+;", // non-deterministic - OK 1024 "(\\w{4})+;", // capturing group - OK 1025 }; 1026 1027 for (int i = 0; i < patterns.length; i++) { 1028 // Check find() 1029 check(patterns[i], 0, input, input, true); 1030 // Check matches() 1031 Pattern p = Pattern.compile(patterns[i]); 1032 Matcher m = p.matcher(input); 1033 1034 if (m.matches()) { 1035 if (!m.group(0).equals(input)) 1036 failCount++; 1037 } else { 1038 failCount++; 1039 } 1040 } 1041 1042 report("Non capturing repetition"); 1043 } 1044 1045 // This test is for 6358731 1046 private static void notCapturedGroupCurlyMatchTest() throws Exception { 1047 Pattern pattern = Pattern.compile("(abc)+|(abcd)+"); 1048 Matcher matcher = pattern.matcher("abcd"); 1049 if (!matcher.matches() || 1050 matcher.group(1) != null || 1051 !matcher.group(2).equals("abcd")) { 1052 failCount++; 1053 } 1054 report("Not captured GroupCurly"); 1055 } 1056 1057 // This test is for 4706545 1058 private static void javaCharClassTest() throws Exception { 1059 for (int i=0; i<1000; i++) { 1060 char c = (char)generator.nextInt(); 1061 check("{javaLowerCase}", c, Character.isLowerCase(c)); 1062 check("{javaUpperCase}", c, Character.isUpperCase(c)); 1063 check("{javaUpperCase}+", c, Character.isUpperCase(c)); 1064 check("{javaTitleCase}", c, Character.isTitleCase(c)); 1065 check("{javaDigit}", c, Character.isDigit(c)); 1066 check("{javaDefined}", c, Character.isDefined(c)); 1067 check("{javaLetter}", c, Character.isLetter(c)); 1068 check("{javaLetterOrDigit}", c, Character.isLetterOrDigit(c)); 1069 check("{javaJavaIdentifierStart}", c, 1070 Character.isJavaIdentifierStart(c)); 1071 check("{javaJavaIdentifierPart}", c, 1072 Character.isJavaIdentifierPart(c)); 1073 check("{javaUnicodeIdentifierStart}", c, 1074 Character.isUnicodeIdentifierStart(c)); 1075 check("{javaUnicodeIdentifierPart}", c, 1076 Character.isUnicodeIdentifierPart(c)); 1077 check("{javaIdentifierIgnorable}", c, 1078 Character.isIdentifierIgnorable(c)); 1079 check("{javaSpaceChar}", c, Character.isSpaceChar(c)); 1080 check("{javaWhitespace}", c, Character.isWhitespace(c)); 1081 check("{javaISOControl}", c, Character.isISOControl(c)); 1082 check("{javaMirrored}", c, Character.isMirrored(c)); 1083 1084 } 1085 1086 // Supplementary character test 1087 for (int i=0; i<1000; i++) { 1088 int c = generator.nextInt(Character.MAX_CODE_POINT 1089 - Character.MIN_SUPPLEMENTARY_CODE_POINT) 1090 + Character.MIN_SUPPLEMENTARY_CODE_POINT; 1091 check("{javaLowerCase}", c, Character.isLowerCase(c)); 1092 check("{javaUpperCase}", c, Character.isUpperCase(c)); 1093 check("{javaUpperCase}+", c, Character.isUpperCase(c)); 1094 check("{javaTitleCase}", c, Character.isTitleCase(c)); 1095 check("{javaDigit}", c, Character.isDigit(c)); 1096 check("{javaDefined}", c, Character.isDefined(c)); 1097 check("{javaLetter}", c, Character.isLetter(c)); 1098 check("{javaLetterOrDigit}", c, Character.isLetterOrDigit(c)); 1099 check("{javaJavaIdentifierStart}", c, 1100 Character.isJavaIdentifierStart(c)); 1101 check("{javaJavaIdentifierPart}", c, 1102 Character.isJavaIdentifierPart(c)); 1103 check("{javaUnicodeIdentifierStart}", c, 1104 Character.isUnicodeIdentifierStart(c)); 1105 check("{javaUnicodeIdentifierPart}", c, 1106 Character.isUnicodeIdentifierPart(c)); 1107 check("{javaIdentifierIgnorable}", c, 1108 Character.isIdentifierIgnorable(c)); 1109 check("{javaSpaceChar}", c, Character.isSpaceChar(c)); 1110 check("{javaWhitespace}", c, Character.isWhitespace(c)); 1111 check("{javaISOControl}", c, Character.isISOControl(c)); 1112 check("{javaMirrored}", c, Character.isMirrored(c)); 1113 } 1114 1115 report("Java character classes"); 1116 } 1117 1118 // This test is for 4523620 1119 /* 1120 private static void numOccurrencesTest() throws Exception { 1121 Pattern pattern = Pattern.compile("aaa"); 1122 1123 if (pattern.numOccurrences("aaaaaa", false) != 2) 1124 failCount++; 1125 if (pattern.numOccurrences("aaaaaa", true) != 4) 1126 failCount++; 1127 1128 pattern = Pattern.compile("^"); 1129 if (pattern.numOccurrences("aaaaaa", false) != 1) 1130 failCount++; 1131 if (pattern.numOccurrences("aaaaaa", true) != 1) 1132 failCount++; 1133 1134 report("Number of Occurrences"); 1135 } 1136 */ 1137 1138 // This test is for 4776374 1139 private static void caretBetweenTerminatorsTest() throws Exception { 1140 int flags1 = Pattern.DOTALL; 1141 int flags2 = Pattern.DOTALL | Pattern.UNIX_LINES; 1142 int flags3 = Pattern.DOTALL | Pattern.UNIX_LINES | Pattern.MULTILINE; 1143 int flags4 = Pattern.DOTALL | Pattern.MULTILINE; 1144 1145 check("^....", flags1, "test\ntest", "test", true); 1146 check(".....^", flags1, "test\ntest", "test", false); 1147 check(".....^", flags1, "test\n", "test", false); 1148 check("....^", flags1, "test\r\n", "test", false); 1149 1150 check("^....", flags2, "test\ntest", "test", true); 1151 check("....^", flags2, "test\ntest", "test", false); 1152 check(".....^", flags2, "test\n", "test", false); 1153 check("....^", flags2, "test\r\n", "test", false); 1154 1155 check("^....", flags3, "test\ntest", "test", true); 1156 check(".....^", flags3, "test\ntest", "test\n", true); 1157 check(".....^", flags3, "test\u0085test", "test\u0085", false); 1158 check(".....^", flags3, "test\n", "test", false); 1159 check(".....^", flags3, "test\r\n", "test", false); 1160 check("......^", flags3, "test\r\ntest", "test\r\n", true); 1161 1162 check("^....", flags4, "test\ntest", "test", true); 1163 check(".....^", flags3, "test\ntest", "test\n", true); 1164 check(".....^", flags4, "test\u0085test", "test\u0085", true); 1165 check(".....^", flags4, "test\n", "test\n", false); 1166 check(".....^", flags4, "test\r\n", "test\r", false); 1167 1168 // Supplementary character test 1169 String t = toSupplementaries("test"); 1170 check("^....", flags1, t+"\n"+t, t, true); 1171 check(".....^", flags1, t+"\n"+t, t, false); 1172 check(".....^", flags1, t+"\n", t, false); 1173 check("....^", flags1, t+"\r\n", t, false); 1174 1175 check("^....", flags2, t+"\n"+t, t, true); 1176 check("....^", flags2, t+"\n"+t, t, false); 1177 check(".....^", flags2, t+"\n", t, false); 1178 check("....^", flags2, t+"\r\n", t, false); 1179 1180 check("^....", flags3, t+"\n"+t, t, true); 1181 check(".....^", flags3, t+"\n"+t, t+"\n", true); 1182 check(".....^", flags3, t+"\u0085"+t, t+"\u0085", false); 1183 check(".....^", flags3, t+"\n", t, false); 1184 check(".....^", flags3, t+"\r\n", t, false); 1185 check("......^", flags3, t+"\r\n"+t, t+"\r\n", true); 1186 1187 check("^....", flags4, t+"\n"+t, t, true); 1188 check(".....^", flags3, t+"\n"+t, t+"\n", true); 1189 check(".....^", flags4, t+"\u0085"+t, t+"\u0085", true); 1190 check(".....^", flags4, t+"\n", t+"\n", false); 1191 check(".....^", flags4, t+"\r\n", t+"\r", false); 1192 1193 report("Caret between terminators"); 1194 } 1195 1196 // This test is for 4727935 1197 private static void dollarAtEndTest() throws Exception { 1198 int flags1 = Pattern.DOTALL; 1199 int flags2 = Pattern.DOTALL | Pattern.UNIX_LINES; 1200 int flags3 = Pattern.DOTALL | Pattern.MULTILINE; 1201 1202 check("....$", flags1, "test\n", "test", true); 1203 check("....$", flags1, "test\r\n", "test", true); 1204 check(".....$", flags1, "test\n", "test\n", true); 1205 check(".....$", flags1, "test\u0085", "test\u0085", true); 1206 check("....$", flags1, "test\u0085", "test", true); 1207 1208 check("....$", flags2, "test\n", "test", true); 1209 check(".....$", flags2, "test\n", "test\n", true); 1210 check(".....$", flags2, "test\u0085", "test\u0085", true); 1211 check("....$", flags2, "test\u0085", "est\u0085", true); 1212 1213 check("....$.blah", flags3, "test\nblah", "test\nblah", true); 1214 check(".....$.blah", flags3, "test\n\nblah", "test\n\nblah", true); 1215 check("....$blah", flags3, "test\nblah", "!!!!", false); 1216 check(".....$blah", flags3, "test\nblah", "!!!!", false); 1217 1218 // Supplementary character test 1219 String t = toSupplementaries("test"); 1220 String b = toSupplementaries("blah"); 1221 check("....$", flags1, t+"\n", t, true); 1222 check("....$", flags1, t+"\r\n", t, true); 1223 check(".....$", flags1, t+"\n", t+"\n", true); 1224 check(".....$", flags1, t+"\u0085", t+"\u0085", true); 1225 check("....$", flags1, t+"\u0085", t, true); 1226 1227 check("....$", flags2, t+"\n", t, true); 1228 check(".....$", flags2, t+"\n", t+"\n", true); 1229 check(".....$", flags2, t+"\u0085", t+"\u0085", true); 1230 check("....$", flags2, t+"\u0085", toSupplementaries("est\u0085"), true); 1231 1232 check("....$."+b, flags3, t+"\n"+b, t+"\n"+b, true); 1233 check(".....$."+b, flags3, t+"\n\n"+b, t+"\n\n"+b, true); 1234 check("....$"+b, flags3, t+"\n"+b, "!!!!", false); 1235 check(".....$"+b, flags3, t+"\n"+b, "!!!!", false); 1236 1237 report("Dollar at End"); 1238 } 1239 1240 // This test is for 4711773 1241 private static void multilineDollarTest() throws Exception { 1242 Pattern findCR = Pattern.compile("$", Pattern.MULTILINE); 1243 Matcher matcher = findCR.matcher("first bit\nsecond bit"); 1244 matcher.find(); 1245 if (matcher.start(0) != 9) 1246 failCount++; 1247 matcher.find(); 1248 if (matcher.start(0) != 20) 1249 failCount++; 1250 1251 // Supplementary character test 1252 matcher = findCR.matcher(toSupplementaries("first bit\n second bit")); // double BMP chars 1253 matcher.find(); 1254 if (matcher.start(0) != 9*2) 1255 failCount++; 1256 matcher.find(); 1257 if (matcher.start(0) != 20*2) 1258 failCount++; 1259 1260 report("Multiline Dollar"); 1261 } 1262 1263 private static void reluctantRepetitionTest() throws Exception { 1264 Pattern p = Pattern.compile("1(\\s\\S+?){1,3}?[\\s,]2"); 1265 check(p, "1 word word word 2", true); 1266 check(p, "1 wor wo w 2", true); 1267 check(p, "1 word word 2", true); 1268 check(p, "1 word 2", true); 1269 check(p, "1 wo w w 2", true); 1270 check(p, "1 wo w 2", true); 1271 check(p, "1 wor w 2", true); 1272 1273 p = Pattern.compile("([a-z])+?c"); 1274 Matcher m = p.matcher("ababcdefdec"); 1275 check(m, "ababc"); 1276 1277 // Supplementary character test 1278 p = Pattern.compile(toSupplementaries("([a-z])+?c")); 1279 m = p.matcher(toSupplementaries("ababcdefdec")); 1280 check(m, toSupplementaries("ababc")); 1281 1282 report("Reluctant Repetition"); 1283 } 1284 1285 private static void serializeTest() throws Exception { 1286 String patternStr = "(b)"; 1287 String matchStr = "b"; 1288 Pattern pattern = Pattern.compile(patternStr); 1289 ByteArrayOutputStream baos = new ByteArrayOutputStream(); 1290 ObjectOutputStream oos = new ObjectOutputStream(baos); 1291 oos.writeObject(pattern); 1292 oos.close(); 1293 ObjectInputStream ois = new ObjectInputStream( 1294 new ByteArrayInputStream(baos.toByteArray())); 1295 Pattern serializedPattern = (Pattern)ois.readObject(); 1296 ois.close(); 1297 Matcher matcher = serializedPattern.matcher(matchStr); 1298 if (!matcher.matches()) 1299 failCount++; 1300 if (matcher.groupCount() != 1) 1301 failCount++; 1302 1303 report("Serialization"); 1304 } 1305 1306 private static void gTest() { 1307 Pattern pattern = Pattern.compile("\\G\\w"); 1308 Matcher matcher = pattern.matcher("abc#x#x"); 1309 matcher.find(); 1310 matcher.find(); 1311 matcher.find(); 1312 if (matcher.find()) 1313 failCount++; 1314 1315 pattern = Pattern.compile("\\GA*"); 1316 matcher = pattern.matcher("1A2AA3"); 1317 matcher.find(); 1318 if (matcher.find()) 1319 failCount++; 1320 1321 pattern = Pattern.compile("\\GA*"); 1322 matcher = pattern.matcher("1A2AA3"); 1323 if (!matcher.find(1)) 1324 failCount++; 1325 matcher.find(); 1326 if (matcher.find()) 1327 failCount++; 1328 1329 report("\\G"); 1330 } 1331 1332 private static void zTest() { 1333 Pattern pattern = Pattern.compile("foo\\Z"); 1334 // Positives 1335 check(pattern, "foo\u0085", true); 1336 check(pattern, "foo\u2028", true); 1337 check(pattern, "foo\u2029", true); 1338 check(pattern, "foo\n", true); 1339 check(pattern, "foo\r", true); 1340 check(pattern, "foo\r\n", true); 1341 // Negatives 1342 check(pattern, "fooo", false); 1343 check(pattern, "foo\n\r", false); 1344 1345 pattern = Pattern.compile("foo\\Z", Pattern.UNIX_LINES); 1346 // Positives 1347 check(pattern, "foo", true); 1348 check(pattern, "foo\n", true); 1349 // Negatives 1350 check(pattern, "foo\r", false); 1351 check(pattern, "foo\u0085", false); 1352 check(pattern, "foo\u2028", false); 1353 check(pattern, "foo\u2029", false); 1354 1355 report("\\Z"); 1356 } 1357 1358 private static void replaceFirstTest() { 1359 Pattern pattern = Pattern.compile("(ab)(c*)"); 1360 Matcher matcher = pattern.matcher("abccczzzabcczzzabccc"); 1361 if (!matcher.replaceFirst("test").equals("testzzzabcczzzabccc")) 1362 failCount++; 1363 1364 matcher.reset("zzzabccczzzabcczzzabccczzz"); 1365 if (!matcher.replaceFirst("test").equals("zzztestzzzabcczzzabccczzz")) 1366 failCount++; 1367 1368 matcher.reset("zzzabccczzzabcczzzabccczzz"); 1369 String result = matcher.replaceFirst("$1"); 1370 if (!result.equals("zzzabzzzabcczzzabccczzz")) 1371 failCount++; 1372 1373 matcher.reset("zzzabccczzzabcczzzabccczzz"); 1374 result = matcher.replaceFirst("$2"); 1375 if (!result.equals("zzzccczzzabcczzzabccczzz")) 1376 failCount++; 1377 1378 pattern = Pattern.compile("a*"); 1379 matcher = pattern.matcher("aaaaaaaaaa"); 1380 if (!matcher.replaceFirst("test").equals("test")) 1381 failCount++; 1382 1383 pattern = Pattern.compile("a+"); 1384 matcher = pattern.matcher("zzzaaaaaaaaaa"); 1385 if (!matcher.replaceFirst("test").equals("zzztest")) 1386 failCount++; 1387 1388 // Supplementary character test 1389 pattern = Pattern.compile(toSupplementaries("(ab)(c*)")); 1390 matcher = pattern.matcher(toSupplementaries("abccczzzabcczzzabccc")); 1391 if (!matcher.replaceFirst(toSupplementaries("test")) 1392 .equals(toSupplementaries("testzzzabcczzzabccc"))) 1393 failCount++; 1394 1395 matcher.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); 1396 if (!matcher.replaceFirst(toSupplementaries("test")). 1397 equals(toSupplementaries("zzztestzzzabcczzzabccczzz"))) 1398 failCount++; 1399 1400 matcher.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); 1401 result = matcher.replaceFirst("$1"); 1402 if (!result.equals(toSupplementaries("zzzabzzzabcczzzabccczzz"))) 1403 failCount++; 1404 1405 matcher.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); 1406 result = matcher.replaceFirst("$2"); 1407 if (!result.equals(toSupplementaries("zzzccczzzabcczzzabccczzz"))) 1408 failCount++; 1409 1410 pattern = Pattern.compile(toSupplementaries("a*")); 1411 matcher = pattern.matcher(toSupplementaries("aaaaaaaaaa")); 1412 if (!matcher.replaceFirst(toSupplementaries("test")).equals(toSupplementaries("test"))) 1413 failCount++; 1414 1415 pattern = Pattern.compile(toSupplementaries("a+")); 1416 matcher = pattern.matcher(toSupplementaries("zzzaaaaaaaaaa")); 1417 if (!matcher.replaceFirst(toSupplementaries("test")).equals(toSupplementaries("zzztest"))) 1418 failCount++; 1419 1420 report("Replace First"); 1421 } 1422 1423 private static void unixLinesTest() { 1424 Pattern pattern = Pattern.compile(".*"); 1425 Matcher matcher = pattern.matcher("aa\u2028blah"); 1426 matcher.find(); 1427 if (!matcher.group(0).equals("aa")) 1428 failCount++; 1429 1430 pattern = Pattern.compile(".*", Pattern.UNIX_LINES); 1431 matcher = pattern.matcher("aa\u2028blah"); 1432 matcher.find(); 1433 if (!matcher.group(0).equals("aa\u2028blah")) 1434 failCount++; 1435 1436 pattern = Pattern.compile("[az]$", 1437 Pattern.MULTILINE | Pattern.UNIX_LINES); 1438 matcher = pattern.matcher("aa\u2028zz"); 1439 check(matcher, "a\u2028", false); 1440 1441 // Supplementary character test 1442 pattern = Pattern.compile(".*"); 1443 matcher = pattern.matcher(toSupplementaries("aa\u2028blah")); 1444 matcher.find(); 1445 if (!matcher.group(0).equals(toSupplementaries("aa"))) 1446 failCount++; 1447 1448 pattern = Pattern.compile(".*", Pattern.UNIX_LINES); 1449 matcher = pattern.matcher(toSupplementaries("aa\u2028blah")); 1450 matcher.find(); 1451 if (!matcher.group(0).equals(toSupplementaries("aa\u2028blah"))) 1452 failCount++; 1453 1454 pattern = Pattern.compile(toSupplementaries("[az]$"), 1455 Pattern.MULTILINE | Pattern.UNIX_LINES); 1456 matcher = pattern.matcher(toSupplementaries("aa\u2028zz")); 1457 check(matcher, toSupplementaries("a\u2028"), false); 1458 1459 report("Unix Lines"); 1460 } 1461 1462 private static void commentsTest() { 1463 int flags = Pattern.COMMENTS; 1464 1465 Pattern pattern = Pattern.compile("aa \\# aa", flags); 1466 Matcher matcher = pattern.matcher("aa#aa"); 1467 if (!matcher.matches()) 1468 failCount++; 1469 1470 pattern = Pattern.compile("aa # blah", flags); 1471 matcher = pattern.matcher("aa"); 1472 if (!matcher.matches()) 1473 failCount++; 1474 1475 pattern = Pattern.compile("aa blah", flags); 1476 matcher = pattern.matcher("aablah"); 1477 if (!matcher.matches()) 1478 failCount++; 1479 1480 pattern = Pattern.compile("aa # blah blech ", flags); 1481 matcher = pattern.matcher("aa"); 1482 if (!matcher.matches()) 1483 failCount++; 1484 1485 pattern = Pattern.compile("aa # blah\n ", flags); 1486 matcher = pattern.matcher("aa"); 1487 if (!matcher.matches()) 1488 failCount++; 1489 1490 pattern = Pattern.compile("aa # blah\nbc # blech", flags); 1491 matcher = pattern.matcher("aabc"); 1492 if (!matcher.matches()) 1493 failCount++; 1494 1495 pattern = Pattern.compile("aa # blah\nbc# blech", flags); 1496 matcher = pattern.matcher("aabc"); 1497 if (!matcher.matches()) 1498 failCount++; 1499 1500 pattern = Pattern.compile("aa # blah\nbc\\# blech", flags); 1501 matcher = pattern.matcher("aabc#blech"); 1502 if (!matcher.matches()) 1503 failCount++; 1504 1505 // Supplementary character test 1506 pattern = Pattern.compile(toSupplementaries("aa \\# aa"), flags); 1507 matcher = pattern.matcher(toSupplementaries("aa#aa")); 1508 if (!matcher.matches()) 1509 failCount++; 1510 1511 pattern = Pattern.compile(toSupplementaries("aa # blah"), flags); 1512 matcher = pattern.matcher(toSupplementaries("aa")); 1513 if (!matcher.matches()) 1514 failCount++; 1515 1516 pattern = Pattern.compile(toSupplementaries("aa blah"), flags); 1517 matcher = pattern.matcher(toSupplementaries("aablah")); 1518 if (!matcher.matches()) 1519 failCount++; 1520 1521 pattern = Pattern.compile(toSupplementaries("aa # blah blech "), flags); 1522 matcher = pattern.matcher(toSupplementaries("aa")); 1523 if (!matcher.matches()) 1524 failCount++; 1525 1526 pattern = Pattern.compile(toSupplementaries("aa # blah\n "), flags); 1527 matcher = pattern.matcher(toSupplementaries("aa")); 1528 if (!matcher.matches()) 1529 failCount++; 1530 1531 pattern = Pattern.compile(toSupplementaries("aa # blah\nbc # blech"), flags); 1532 matcher = pattern.matcher(toSupplementaries("aabc")); 1533 if (!matcher.matches()) 1534 failCount++; 1535 1536 pattern = Pattern.compile(toSupplementaries("aa # blah\nbc# blech"), flags); 1537 matcher = pattern.matcher(toSupplementaries("aabc")); 1538 if (!matcher.matches()) 1539 failCount++; 1540 1541 pattern = Pattern.compile(toSupplementaries("aa # blah\nbc\\# blech"), flags); 1542 matcher = pattern.matcher(toSupplementaries("aabc#blech")); 1543 if (!matcher.matches()) 1544 failCount++; 1545 1546 report("Comments"); 1547 } 1548 1549 private static void caseFoldingTest() { // bug 4504687 1550 int flags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE; 1551 Pattern pattern = Pattern.compile("aa", flags); 1552 Matcher matcher = pattern.matcher("ab"); 1553 if (matcher.matches()) 1554 failCount++; 1555 1556 pattern = Pattern.compile("aA", flags); 1557 matcher = pattern.matcher("ab"); 1558 if (matcher.matches()) 1559 failCount++; 1560 1561 pattern = Pattern.compile("aa", flags); 1562 matcher = pattern.matcher("aB"); 1563 if (matcher.matches()) 1564 failCount++; 1565 matcher = pattern.matcher("Ab"); 1566 if (matcher.matches()) 1567 failCount++; 1568 1569 // ASCII "a" 1570 // Latin-1 Supplement "a" + grave 1571 // Cyrillic "a" 1572 String[] patterns = new String[] { 1573 //single 1574 "a", "\u00e0", "\u0430", 1575 //slice 1576 "ab", "\u00e0\u00e1", "\u0430\u0431", 1577 //class single 1578 "[a]", "[\u00e0]", "[\u0430]", 1579 //class range 1580 "[a-b]", "[\u00e0-\u00e5]", "[\u0430-\u0431]", 1581 //back reference 1582 "(a)\\1", "(\u00e0)\\1", "(\u0430)\\1" 1583 }; 1584 1585 String[] texts = new String[] { 1586 "A", "\u00c0", "\u0410", 1587 "AB", "\u00c0\u00c1", "\u0410\u0411", 1588 "A", "\u00c0", "\u0410", 1589 "B", "\u00c2", "\u0411", 1590 "aA", "\u00e0\u00c0", "\u0430\u0410" 1591 }; 1592 1593 boolean[] expected = new boolean[] { 1594 true, false, false, 1595 true, false, false, 1596 true, false, false, 1597 true, false, false, 1598 true, false, false 1599 }; 1600 1601 flags = Pattern.CASE_INSENSITIVE; 1602 for (int i = 0; i < patterns.length; i++) { 1603 pattern = Pattern.compile(patterns[i], flags); 1604 matcher = pattern.matcher(texts[i]); 1605 if (matcher.matches() != expected[i]) { 1606 System.out.println("<1> Failed at " + i); 1607 failCount++; 1608 } 1609 } 1610 1611 flags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE; 1612 for (int i = 0; i < patterns.length; i++) { 1613 pattern = Pattern.compile(patterns[i], flags); 1614 matcher = pattern.matcher(texts[i]); 1615 if (!matcher.matches()) { 1616 System.out.println("<2> Failed at " + i); 1617 failCount++; 1618 } 1619 } 1620 // flag unicode_case alone should do nothing 1621 flags = Pattern.UNICODE_CASE; 1622 for (int i = 0; i < patterns.length; i++) { 1623 pattern = Pattern.compile(patterns[i], flags); 1624 matcher = pattern.matcher(texts[i]); 1625 if (matcher.matches()) { 1626 System.out.println("<3> Failed at " + i); 1627 failCount++; 1628 } 1629 } 1630 1631 // Special cases: i, I, u+0131 and u+0130 1632 flags = Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE; 1633 pattern = Pattern.compile("[h-j]+", flags); 1634 if (!pattern.matcher("\u0131\u0130").matches()) 1635 failCount++; 1636 report("Case Folding"); 1637 } 1638 1639 private static void appendTest() { 1640 Pattern pattern = Pattern.compile("(ab)(cd)"); 1641 Matcher matcher = pattern.matcher("abcd"); 1642 String result = matcher.replaceAll("$2$1"); 1643 if (!result.equals("cdab")) 1644 failCount++; 1645 1646 String s1 = "Swap all: first = 123, second = 456"; 1647 String s2 = "Swap one: first = 123, second = 456"; 1648 String r = "$3$2$1"; 1649 pattern = Pattern.compile("([a-z]+)( *= *)([0-9]+)"); 1650 matcher = pattern.matcher(s1); 1651 1652 result = matcher.replaceAll(r); 1653 if (!result.equals("Swap all: 123 = first, 456 = second")) 1654 failCount++; 1655 1656 matcher = pattern.matcher(s2); 1657 1658 if (matcher.find()) { 1659 StringBuffer sb = new StringBuffer(); 1660 matcher.appendReplacement(sb, r); 1661 matcher.appendTail(sb); 1662 result = sb.toString(); 1663 if (!result.equals("Swap one: 123 = first, second = 456")) 1664 failCount++; 1665 } 1666 1667 // Supplementary character test 1668 pattern = Pattern.compile(toSupplementaries("(ab)(cd)")); 1669 matcher = pattern.matcher(toSupplementaries("abcd")); 1670 result = matcher.replaceAll("$2$1"); 1671 if (!result.equals(toSupplementaries("cdab"))) 1672 failCount++; 1673 1674 s1 = toSupplementaries("Swap all: first = 123, second = 456"); 1675 s2 = toSupplementaries("Swap one: first = 123, second = 456"); 1676 r = toSupplementaries("$3$2$1"); 1677 pattern = Pattern.compile(toSupplementaries("([a-z]+)( *= *)([0-9]+)")); 1678 matcher = pattern.matcher(s1); 1679 1680 result = matcher.replaceAll(r); 1681 if (!result.equals(toSupplementaries("Swap all: 123 = first, 456 = second"))) 1682 failCount++; 1683 1684 matcher = pattern.matcher(s2); 1685 1686 if (matcher.find()) { 1687 StringBuffer sb = new StringBuffer(); 1688 matcher.appendReplacement(sb, r); 1689 matcher.appendTail(sb); 1690 result = sb.toString(); 1691 if (!result.equals(toSupplementaries("Swap one: 123 = first, second = 456"))) 1692 failCount++; 1693 } 1694 report("Append"); 1695 } 1696 1697 private static void splitTest() { 1698 Pattern pattern = Pattern.compile(":"); 1699 String[] result = pattern.split("foo:and:boo", 2); 1700 if (!result[0].equals("foo")) 1701 failCount++; 1702 if (!result[1].equals("and:boo")) 1703 failCount++; 1704 // Supplementary character test 1705 Pattern patternX = Pattern.compile(toSupplementaries("X")); 1706 result = patternX.split(toSupplementaries("fooXandXboo"), 2); 1707 if (!result[0].equals(toSupplementaries("foo"))) 1708 failCount++; 1709 if (!result[1].equals(toSupplementaries("andXboo"))) 1710 failCount++; 1711 1712 CharBuffer cb = CharBuffer.allocate(100); 1713 cb.put("foo:and:boo"); 1714 cb.flip(); 1715 result = pattern.split(cb); 1716 if (!result[0].equals("foo")) 1717 failCount++; 1718 if (!result[1].equals("and")) 1719 failCount++; 1720 if (!result[2].equals("boo")) 1721 failCount++; 1722 1723 // Supplementary character test 1724 CharBuffer cbs = CharBuffer.allocate(100); 1725 cbs.put(toSupplementaries("fooXandXboo")); 1726 cbs.flip(); 1727 result = patternX.split(cbs); 1728 if (!result[0].equals(toSupplementaries("foo"))) 1729 failCount++; 1730 if (!result[1].equals(toSupplementaries("and"))) 1731 failCount++; 1732 if (!result[2].equals(toSupplementaries("boo"))) 1733 failCount++; 1734 1735 String source = "0123456789"; 1736 for (int limit=-2; limit<3; limit++) { 1737 for (int x=0; x<10; x++) { 1738 result = source.split(Integer.toString(x), limit); 1739 int expectedLength = limit < 1 ? 2 : limit; 1740 1741 if ((limit == 0) && (x == 9)) { 1742 // expected dropping of "" 1743 if (result.length != 1) 1744 failCount++; 1745 if (!result[0].equals("012345678")) { 1746 failCount++; 1747 } 1748 } else { 1749 if (result.length != expectedLength) { 1750 failCount++; 1751 } 1752 if (!result[0].equals(source.substring(0,x))) { 1753 if (limit != 1) { 1754 failCount++; 1755 } else { 1756 if (!result[0].equals(source.substring(0,10))) { 1757 failCount++; 1758 } 1759 } 1760 } 1761 if (expectedLength > 1) { // Check segment 2 1762 if (!result[1].equals(source.substring(x+1,10))) 1763 failCount++; 1764 } 1765 } 1766 } 1767 } 1768 // Check the case for no match found 1769 for (int limit=-2; limit<3; limit++) { 1770 result = source.split("e", limit); 1771 if (result.length != 1) 1772 failCount++; 1773 if (!result[0].equals(source)) 1774 failCount++; 1775 } 1776 // Check the case for limit == 0, source = ""; 1777 source = ""; 1778 result = source.split("e", 0); 1779 if (result.length != 1) 1780 failCount++; 1781 if (!result[0].equals(source)) 1782 failCount++; 1783 1784 report("Split"); 1785 } 1786 1787 private static void negationTest() { 1788 Pattern pattern = Pattern.compile("[\\[@^]+"); 1789 Matcher matcher = pattern.matcher("@@@@[[[[^^^^"); 1790 if (!matcher.find()) 1791 failCount++; 1792 if (!matcher.group(0).equals("@@@@[[[[^^^^")) 1793 failCount++; 1794 pattern = Pattern.compile("[@\\[^]+"); 1795 matcher = pattern.matcher("@@@@[[[[^^^^"); 1796 if (!matcher.find()) 1797 failCount++; 1798 if (!matcher.group(0).equals("@@@@[[[[^^^^")) 1799 failCount++; 1800 pattern = Pattern.compile("[@\\[^@]+"); 1801 matcher = pattern.matcher("@@@@[[[[^^^^"); 1802 if (!matcher.find()) 1803 failCount++; 1804 if (!matcher.group(0).equals("@@@@[[[[^^^^")) 1805 failCount++; 1806 1807 pattern = Pattern.compile("\\)"); 1808 matcher = pattern.matcher("xxx)xxx"); 1809 if (!matcher.find()) 1810 failCount++; 1811 1812 report("Negation"); 1813 } 1814 1815 private static void ampersandTest() { 1816 Pattern pattern = Pattern.compile("[&@]+"); 1817 check(pattern, "@@@@&&&&", true); 1818 1819 pattern = Pattern.compile("[@&]+"); 1820 check(pattern, "@@@@&&&&", true); 1821 1822 pattern = Pattern.compile("[@\\&]+"); 1823 check(pattern, "@@@@&&&&", true); 1824 1825 report("Ampersand"); 1826 } 1827 1828 private static void octalTest() throws Exception { 1829 Pattern pattern = Pattern.compile("\\u0007"); 1830 Matcher matcher = pattern.matcher("\u0007"); 1831 if (!matcher.matches()) 1832 failCount++; 1833 pattern = Pattern.compile("\\07"); 1834 matcher = pattern.matcher("\u0007"); 1835 if (!matcher.matches()) 1836 failCount++; 1837 pattern = Pattern.compile("\\007"); 1838 matcher = pattern.matcher("\u0007"); 1839 if (!matcher.matches()) 1840 failCount++; 1841 pattern = Pattern.compile("\\0007"); 1842 matcher = pattern.matcher("\u0007"); 1843 if (!matcher.matches()) 1844 failCount++; 1845 pattern = Pattern.compile("\\040"); 1846 matcher = pattern.matcher("\u0020"); 1847 if (!matcher.matches()) 1848 failCount++; 1849 pattern = Pattern.compile("\\0403"); 1850 matcher = pattern.matcher("\u00203"); 1851 if (!matcher.matches()) 1852 failCount++; 1853 pattern = Pattern.compile("\\0103"); 1854 matcher = pattern.matcher("\u0043"); 1855 if (!matcher.matches()) 1856 failCount++; 1857 1858 report("Octal"); 1859 } 1860 1861 private static void longPatternTest() throws Exception { 1862 try { 1863 Pattern pattern = Pattern.compile( 1864 "a 32-character-long pattern xxxx"); 1865 pattern = Pattern.compile("a 33-character-long pattern xxxxx"); 1866 pattern = Pattern.compile("a thirty four character long regex"); 1867 StringBuffer patternToBe = new StringBuffer(101); 1868 for (int i=0; i<100; i++) 1869 patternToBe.append((char)(97 + i%26)); 1870 pattern = Pattern.compile(patternToBe.toString()); 1871 } catch (PatternSyntaxException e) { 1872 failCount++; 1873 } 1874 1875 // Supplementary character test 1876 try { 1877 Pattern pattern = Pattern.compile( 1878 toSupplementaries("a 32-character-long pattern xxxx")); 1879 pattern = Pattern.compile(toSupplementaries("a 33-character-long pattern xxxxx")); 1880 pattern = Pattern.compile(toSupplementaries("a thirty four character long regex")); 1881 StringBuffer patternToBe = new StringBuffer(101*2); 1882 for (int i=0; i<100; i++) 1883 patternToBe.append(Character.toChars(Character.MIN_SUPPLEMENTARY_CODE_POINT 1884 + 97 + i%26)); 1885 pattern = Pattern.compile(patternToBe.toString()); 1886 } catch (PatternSyntaxException e) { 1887 failCount++; 1888 } 1889 report("LongPattern"); 1890 } 1891 1892 private static void group0Test() throws Exception { 1893 Pattern pattern = Pattern.compile("(tes)ting"); 1894 Matcher matcher = pattern.matcher("testing"); 1895 check(matcher, "testing"); 1896 1897 matcher.reset("testing"); 1898 if (matcher.lookingAt()) { 1899 if (!matcher.group(0).equals("testing")) 1900 failCount++; 1901 } else { 1902 failCount++; 1903 } 1904 1905 matcher.reset("testing"); 1906 if (matcher.matches()) { 1907 if (!matcher.group(0).equals("testing")) 1908 failCount++; 1909 } else { 1910 failCount++; 1911 } 1912 1913 pattern = Pattern.compile("(tes)ting"); 1914 matcher = pattern.matcher("testing"); 1915 if (matcher.lookingAt()) { 1916 if (!matcher.group(0).equals("testing")) 1917 failCount++; 1918 } else { 1919 failCount++; 1920 } 1921 1922 pattern = Pattern.compile("^(tes)ting"); 1923 matcher = pattern.matcher("testing"); 1924 if (matcher.matches()) { 1925 if (!matcher.group(0).equals("testing")) 1926 failCount++; 1927 } else { 1928 failCount++; 1929 } 1930 1931 // Supplementary character test 1932 pattern = Pattern.compile(toSupplementaries("(tes)ting")); 1933 matcher = pattern.matcher(toSupplementaries("testing")); 1934 check(matcher, toSupplementaries("testing")); 1935 1936 matcher.reset(toSupplementaries("testing")); 1937 if (matcher.lookingAt()) { 1938 if (!matcher.group(0).equals(toSupplementaries("testing"))) 1939 failCount++; 1940 } else { 1941 failCount++; 1942 } 1943 1944 matcher.reset(toSupplementaries("testing")); 1945 if (matcher.matches()) { 1946 if (!matcher.group(0).equals(toSupplementaries("testing"))) 1947 failCount++; 1948 } else { 1949 failCount++; 1950 } 1951 1952 pattern = Pattern.compile(toSupplementaries("(tes)ting")); 1953 matcher = pattern.matcher(toSupplementaries("testing")); 1954 if (matcher.lookingAt()) { 1955 if (!matcher.group(0).equals(toSupplementaries("testing"))) 1956 failCount++; 1957 } else { 1958 failCount++; 1959 } 1960 1961 pattern = Pattern.compile(toSupplementaries("^(tes)ting")); 1962 matcher = pattern.matcher(toSupplementaries("testing")); 1963 if (matcher.matches()) { 1964 if (!matcher.group(0).equals(toSupplementaries("testing"))) 1965 failCount++; 1966 } else { 1967 failCount++; 1968 } 1969 1970 report("Group0"); 1971 } 1972 1973 private static void findIntTest() throws Exception { 1974 Pattern p = Pattern.compile("blah"); 1975 Matcher m = p.matcher("zzzzblahzzzzzblah"); 1976 boolean result = m.find(2); 1977 if (!result) 1978 failCount++; 1979 1980 p = Pattern.compile("$"); 1981 m = p.matcher("1234567890"); 1982 result = m.find(10); 1983 if (!result) 1984 failCount++; 1985 try { 1986 result = m.find(11); 1987 failCount++; 1988 } catch (IndexOutOfBoundsException e) { 1989 // correct result 1990 } 1991 1992 // Supplementary character test 1993 p = Pattern.compile(toSupplementaries("blah")); 1994 m = p.matcher(toSupplementaries("zzzzblahzzzzzblah")); 1995 result = m.find(2); 1996 if (!result) 1997 failCount++; 1998 1999 report("FindInt"); 2000 } 2001 2002 private static void emptyPatternTest() throws Exception { 2003 Pattern p = Pattern.compile(""); 2004 Matcher m = p.matcher("foo"); 2005 2006 // Should find empty pattern at beginning of input 2007 boolean result = m.find(); 2008 if (result != true) 2009 failCount++; 2010 if (m.start() != 0) 2011 failCount++; 2012 2013 // Should not match entire input if input is not empty 2014 m.reset(); 2015 result = m.matches(); 2016 if (result == true) 2017 failCount++; 2018 2019 try { 2020 m.start(0); 2021 failCount++; 2022 } catch (IllegalStateException e) { 2023 // Correct result 2024 } 2025 2026 // Should match entire input if input is empty 2027 m.reset(""); 2028 result = m.matches(); 2029 if (result != true) 2030 failCount++; 2031 2032 result = Pattern.matches("", ""); 2033 if (result != true) 2034 failCount++; 2035 2036 result = Pattern.matches("", "foo"); 2037 if (result == true) 2038 failCount++; 2039 report("EmptyPattern"); 2040 } 2041 2042 private static void charClassTest() throws Exception { 2043 Pattern pattern = Pattern.compile("blah[ab]]blech"); 2044 check(pattern, "blahb]blech", true); 2045 2046 pattern = Pattern.compile("[abc[def]]"); 2047 check(pattern, "b", true); 2048 2049 // Supplementary character tests 2050 pattern = Pattern.compile(toSupplementaries("blah[ab]]blech")); 2051 check(pattern, toSupplementaries("blahb]blech"), true); 2052 2053 pattern = Pattern.compile(toSupplementaries("[abc[def]]")); 2054 check(pattern, toSupplementaries("b"), true); 2055 2056 try { 2057 // u00ff when UNICODE_CASE 2058 pattern = Pattern.compile("[ab\u00ffcd]", 2059 Pattern.CASE_INSENSITIVE| 2060 Pattern.UNICODE_CASE); 2061 check(pattern, "ab\u00ffcd", true); 2062 check(pattern, "Ab\u0178Cd", true); 2063 2064 // u00b5 when UNICODE_CASE 2065 pattern = Pattern.compile("[ab\u00b5cd]", 2066 Pattern.CASE_INSENSITIVE| 2067 Pattern.UNICODE_CASE); 2068 check(pattern, "ab\u00b5cd", true); 2069 check(pattern, "Ab\u039cCd", true); 2070 } catch (Exception e) { failCount++; } 2071 2072 /* Special cases 2073 (1)LatinSmallLetterLongS u+017f 2074 (2)LatinSmallLetterDotlessI u+0131 2075 (3)LatineCapitalLetterIWithDotAbove u+0130 2076 (4)KelvinSign u+212a 2077 (5)AngstromSign u+212b 2078 */ 2079 int flags = Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE; 2080 pattern = Pattern.compile("[sik\u00c5]+", flags); 2081 if (!pattern.matcher("\u017f\u0130\u0131\u212a\u212b").matches()) 2082 failCount++; 2083 2084 report("CharClass"); 2085 } 2086 2087 private static void caretTest() throws Exception { 2088 Pattern pattern = Pattern.compile("\\w*"); 2089 Matcher matcher = pattern.matcher("a#bc#def##g"); 2090 check(matcher, "a"); 2091 check(matcher, ""); 2092 check(matcher, "bc"); 2093 check(matcher, ""); 2094 check(matcher, "def"); 2095 check(matcher, ""); 2096 check(matcher, ""); 2097 check(matcher, "g"); 2098 check(matcher, ""); 2099 if (matcher.find()) 2100 failCount++; 2101 2102 pattern = Pattern.compile("^\\w*"); 2103 matcher = pattern.matcher("a#bc#def##g"); 2104 check(matcher, "a"); 2105 if (matcher.find()) 2106 failCount++; 2107 2108 pattern = Pattern.compile("\\w"); 2109 matcher = pattern.matcher("abc##x"); 2110 check(matcher, "a"); 2111 check(matcher, "b"); 2112 check(matcher, "c"); 2113 check(matcher, "x"); 2114 if (matcher.find()) 2115 failCount++; 2116 2117 pattern = Pattern.compile("^\\w"); 2118 matcher = pattern.matcher("abc##x"); 2119 check(matcher, "a"); 2120 if (matcher.find()) 2121 failCount++; 2122 2123 pattern = Pattern.compile("\\A\\p{Alpha}{3}"); 2124 matcher = pattern.matcher("abcdef-ghi\njklmno"); 2125 check(matcher, "abc"); 2126 if (matcher.find()) 2127 failCount++; 2128 2129 pattern = Pattern.compile("^\\p{Alpha}{3}", Pattern.MULTILINE); 2130 matcher = pattern.matcher("abcdef-ghi\njklmno"); 2131 check(matcher, "abc"); 2132 check(matcher, "jkl"); 2133 if (matcher.find()) 2134 failCount++; 2135 2136 pattern = Pattern.compile("^", Pattern.MULTILINE); 2137 matcher = pattern.matcher("this is some text"); 2138 String result = matcher.replaceAll("X"); 2139 if (!result.equals("Xthis is some text")) 2140 failCount++; 2141 2142 pattern = Pattern.compile("^"); 2143 matcher = pattern.matcher("this is some text"); 2144 result = matcher.replaceAll("X"); 2145 if (!result.equals("Xthis is some text")) 2146 failCount++; 2147 2148 pattern = Pattern.compile("^", Pattern.MULTILINE | Pattern.UNIX_LINES); 2149 matcher = pattern.matcher("this is some text\n"); 2150 result = matcher.replaceAll("X"); 2151 if (!result.equals("Xthis is some text\n")) 2152 failCount++; 2153 2154 report("Caret"); 2155 } 2156 2157 private static void groupCaptureTest() throws Exception { 2158 // Independent group 2159 Pattern pattern = Pattern.compile("x+(?>y+)z+"); 2160 Matcher matcher = pattern.matcher("xxxyyyzzz"); 2161 matcher.find(); 2162 try { 2163 String blah = matcher.group(1); 2164 failCount++; 2165 } catch (IndexOutOfBoundsException ioobe) { 2166 // Good result 2167 } 2168 // Pure group 2169 pattern = Pattern.compile("x+(?:y+)z+"); 2170 matcher = pattern.matcher("xxxyyyzzz"); 2171 matcher.find(); 2172 try { 2173 String blah = matcher.group(1); 2174 failCount++; 2175 } catch (IndexOutOfBoundsException ioobe) { 2176 // Good result 2177 } 2178 2179 // Supplementary character tests 2180 // Independent group 2181 pattern = Pattern.compile(toSupplementaries("x+(?>y+)z+")); 2182 matcher = pattern.matcher(toSupplementaries("xxxyyyzzz")); 2183 matcher.find(); 2184 try { 2185 String blah = matcher.group(1); 2186 failCount++; 2187 } catch (IndexOutOfBoundsException ioobe) { 2188 // Good result 2189 } 2190 // Pure group 2191 pattern = Pattern.compile(toSupplementaries("x+(?:y+)z+")); 2192 matcher = pattern.matcher(toSupplementaries("xxxyyyzzz")); 2193 matcher.find(); 2194 try { 2195 String blah = matcher.group(1); 2196 failCount++; 2197 } catch (IndexOutOfBoundsException ioobe) { 2198 // Good result 2199 } 2200 2201 report("GroupCapture"); 2202 } 2203 2204 private static void backRefTest() throws Exception { 2205 Pattern pattern = Pattern.compile("(a*)bc\\1"); 2206 check(pattern, "zzzaabcazzz", true); 2207 2208 pattern = Pattern.compile("(a*)bc\\1"); 2209 check(pattern, "zzzaabcaazzz", true); 2210 2211 pattern = Pattern.compile("(abc)(def)\\1"); 2212 check(pattern, "abcdefabc", true); 2213 2214 pattern = Pattern.compile("(abc)(def)\\3"); 2215 check(pattern, "abcdefabc", false); 2216 2217 try { 2218 for (int i = 1; i < 10; i++) { 2219 // Make sure backref 1-9 are always accepted 2220 pattern = Pattern.compile("abcdef\\" + i); 2221 // and fail to match if the target group does not exit 2222 check(pattern, "abcdef", false); 2223 } 2224 } catch(PatternSyntaxException e) { 2225 failCount++; 2226 } 2227 2228 pattern = Pattern.compile("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\\11"); 2229 check(pattern, "abcdefghija", false); 2230 check(pattern, "abcdefghija1", true); 2231 2232 pattern = Pattern.compile("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11"); 2233 check(pattern, "abcdefghijkk", true); 2234 2235 pattern = Pattern.compile("(a)bcdefghij\\11"); 2236 check(pattern, "abcdefghija1", true); 2237 2238 // Supplementary character tests 2239 pattern = Pattern.compile(toSupplementaries("(a*)bc\\1")); 2240 check(pattern, toSupplementaries("zzzaabcazzz"), true); 2241 2242 pattern = Pattern.compile(toSupplementaries("(a*)bc\\1")); 2243 check(pattern, toSupplementaries("zzzaabcaazzz"), true); 2244 2245 pattern = Pattern.compile(toSupplementaries("(abc)(def)\\1")); 2246 check(pattern, toSupplementaries("abcdefabc"), true); 2247 2248 pattern = Pattern.compile(toSupplementaries("(abc)(def)\\3")); 2249 check(pattern, toSupplementaries("abcdefabc"), false); 2250 2251 pattern = Pattern.compile(toSupplementaries("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\\11")); 2252 check(pattern, toSupplementaries("abcdefghija"), false); 2253 check(pattern, toSupplementaries("abcdefghija1"), true); 2254 2255 pattern = Pattern.compile(toSupplementaries("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11")); 2256 check(pattern, toSupplementaries("abcdefghijkk"), true); 2257 2258 report("BackRef"); 2259 } 2260 2261 /** 2262 * Unicode Technical Report #18, section 2.6 End of Line 2263 * There is no empty line to be matched in the sequence \u000D\u000A 2264 * but there is an empty line in the sequence \u000A\u000D. 2265 */ 2266 private static void anchorTest() throws Exception { 2267 Pattern p = Pattern.compile("^.*$", Pattern.MULTILINE); 2268 Matcher m = p.matcher("blah1\r\nblah2"); 2269 m.find(); 2270 m.find(); 2271 if (!m.group().equals("blah2")) 2272 failCount++; 2273 2274 m.reset("blah1\n\rblah2"); 2275 m.find(); 2276 m.find(); 2277 m.find(); 2278 if (!m.group().equals("blah2")) 2279 failCount++; 2280 2281 // Test behavior of $ with \r\n at end of input 2282 p = Pattern.compile(".+$"); 2283 m = p.matcher("blah1\r\n"); 2284 if (!m.find()) 2285 failCount++; 2286 if (!m.group().equals("blah1")) 2287 failCount++; 2288 if (m.find()) 2289 failCount++; 2290 2291 // Test behavior of $ with \r\n at end of input in multiline 2292 p = Pattern.compile(".+$", Pattern.MULTILINE); 2293 m = p.matcher("blah1\r\n"); 2294 if (!m.find()) 2295 failCount++; 2296 if (m.find()) 2297 failCount++; 2298 2299 // Test for $ recognition of \u0085 for bug 4527731 2300 p = Pattern.compile(".+$", Pattern.MULTILINE); 2301 m = p.matcher("blah1\u0085"); 2302 if (!m.find()) 2303 failCount++; 2304 2305 // Supplementary character test 2306 p = Pattern.compile("^.*$", Pattern.MULTILINE); 2307 m = p.matcher(toSupplementaries("blah1\r\nblah2")); 2308 m.find(); 2309 m.find(); 2310 if (!m.group().equals(toSupplementaries("blah2"))) 2311 failCount++; 2312 2313 m.reset(toSupplementaries("blah1\n\rblah2")); 2314 m.find(); 2315 m.find(); 2316 m.find(); 2317 if (!m.group().equals(toSupplementaries("blah2"))) 2318 failCount++; 2319 2320 // Test behavior of $ with \r\n at end of input 2321 p = Pattern.compile(".+$"); 2322 m = p.matcher(toSupplementaries("blah1\r\n")); 2323 if (!m.find()) 2324 failCount++; 2325 if (!m.group().equals(toSupplementaries("blah1"))) 2326 failCount++; 2327 if (m.find()) 2328 failCount++; 2329 2330 // Test behavior of $ with \r\n at end of input in multiline 2331 p = Pattern.compile(".+$", Pattern.MULTILINE); 2332 m = p.matcher(toSupplementaries("blah1\r\n")); 2333 if (!m.find()) 2334 failCount++; 2335 if (m.find()) 2336 failCount++; 2337 2338 // Test for $ recognition of \u0085 for bug 4527731 2339 p = Pattern.compile(".+$", Pattern.MULTILINE); 2340 m = p.matcher(toSupplementaries("blah1\u0085")); 2341 if (!m.find()) 2342 failCount++; 2343 2344 report("Anchors"); 2345 } 2346 2347 /** 2348 * A basic sanity test of Matcher.lookingAt(). 2349 */ 2350 private static void lookingAtTest() throws Exception { 2351 Pattern p = Pattern.compile("(ab)(c*)"); 2352 Matcher m = p.matcher("abccczzzabcczzzabccc"); 2353 2354 if (!m.lookingAt()) 2355 failCount++; 2356 2357 if (!m.group().equals(m.group(0))) 2358 failCount++; 2359 2360 m = p.matcher("zzzabccczzzabcczzzabccczzz"); 2361 if (m.lookingAt()) 2362 failCount++; 2363 2364 // Supplementary character test 2365 p = Pattern.compile(toSupplementaries("(ab)(c*)")); 2366 m = p.matcher(toSupplementaries("abccczzzabcczzzabccc")); 2367 2368 if (!m.lookingAt()) 2369 failCount++; 2370 2371 if (!m.group().equals(m.group(0))) 2372 failCount++; 2373 2374 m = p.matcher(toSupplementaries("zzzabccczzzabcczzzabccczzz")); 2375 if (m.lookingAt()) 2376 failCount++; 2377 2378 report("Looking At"); 2379 } 2380 2381 /** 2382 * A basic sanity test of Matcher.matches(). 2383 */ 2384 private static void matchesTest() throws Exception { 2385 // matches() 2386 Pattern p = Pattern.compile("ulb(c*)"); 2387 Matcher m = p.matcher("ulbcccccc"); 2388 if (!m.matches()) 2389 failCount++; 2390 2391 // find() but not matches() 2392 m.reset("zzzulbcccccc"); 2393 if (m.matches()) 2394 failCount++; 2395 2396 // lookingAt() but not matches() 2397 m.reset("ulbccccccdef"); 2398 if (m.matches()) 2399 failCount++; 2400 2401 // matches() 2402 p = Pattern.compile("a|ad"); 2403 m = p.matcher("ad"); 2404 if (!m.matches()) 2405 failCount++; 2406 2407 // Supplementary character test 2408 // matches() 2409 p = Pattern.compile(toSupplementaries("ulb(c*)")); 2410 m = p.matcher(toSupplementaries("ulbcccccc")); 2411 if (!m.matches()) 2412 failCount++; 2413 2414 // find() but not matches() 2415 m.reset(toSupplementaries("zzzulbcccccc")); 2416 if (m.matches()) 2417 failCount++; 2418 2419 // lookingAt() but not matches() 2420 m.reset(toSupplementaries("ulbccccccdef")); 2421 if (m.matches()) 2422 failCount++; 2423 2424 // matches() 2425 p = Pattern.compile(toSupplementaries("a|ad")); 2426 m = p.matcher(toSupplementaries("ad")); 2427 if (!m.matches()) 2428 failCount++; 2429 2430 report("Matches"); 2431 } 2432 2433 /** 2434 * A basic sanity test of Pattern.matches(). 2435 */ 2436 private static void patternMatchesTest() throws Exception { 2437 // matches() 2438 if (!Pattern.matches(toSupplementaries("ulb(c*)"), 2439 toSupplementaries("ulbcccccc"))) 2440 failCount++; 2441 2442 // find() but not matches() 2443 if (Pattern.matches(toSupplementaries("ulb(c*)"), 2444 toSupplementaries("zzzulbcccccc"))) 2445 failCount++; 2446 2447 // lookingAt() but not matches() 2448 if (Pattern.matches(toSupplementaries("ulb(c*)"), 2449 toSupplementaries("ulbccccccdef"))) 2450 failCount++; 2451 2452 // Supplementary character test 2453 // matches() 2454 if (!Pattern.matches(toSupplementaries("ulb(c*)"), 2455 toSupplementaries("ulbcccccc"))) 2456 failCount++; 2457 2458 // find() but not matches() 2459 if (Pattern.matches(toSupplementaries("ulb(c*)"), 2460 toSupplementaries("zzzulbcccccc"))) 2461 failCount++; 2462 2463 // lookingAt() but not matches() 2464 if (Pattern.matches(toSupplementaries("ulb(c*)"), 2465 toSupplementaries("ulbccccccdef"))) 2466 failCount++; 2467 2468 report("Pattern Matches"); 2469 } 2470 2471 /** 2472 * Canonical equivalence testing. Tests the ability of the engine 2473 * to match sequences that are not explicitly specified in the 2474 * pattern when they are considered equivalent by the Unicode Standard. 2475 */ 2476 private static void ceTest() throws Exception { 2477 // Decomposed char outside char classes 2478 Pattern p = Pattern.compile("testa\u030a", Pattern.CANON_EQ); 2479 Matcher m = p.matcher("test\u00e5"); 2480 if (!m.matches()) 2481 failCount++; 2482 2483 m.reset("testa\u030a"); 2484 if (!m.matches()) 2485 failCount++; 2486 2487 // Composed char outside char classes 2488 p = Pattern.compile("test\u00e5", Pattern.CANON_EQ); 2489 m = p.matcher("test\u00e5"); 2490 if (!m.matches()) 2491 failCount++; 2492 2493 m.reset("testa\u030a"); 2494 if (!m.find()) 2495 failCount++; 2496 2497 // Decomposed char inside a char class 2498 p = Pattern.compile("test[abca\u030a]", Pattern.CANON_EQ); 2499 m = p.matcher("test\u00e5"); 2500 if (!m.find()) 2501 failCount++; 2502 2503 m.reset("testa\u030a"); 2504 if (!m.find()) 2505 failCount++; 2506 2507 // Composed char inside a char class 2508 p = Pattern.compile("test[abc\u00e5def\u00e0]", Pattern.CANON_EQ); 2509 m = p.matcher("test\u00e5"); 2510 if (!m.find()) 2511 failCount++; 2512 2513 m.reset("testa\u0300"); 2514 if (!m.find()) 2515 failCount++; 2516 2517 m.reset("testa\u030a"); 2518 if (!m.find()) 2519 failCount++; 2520 2521 // Marks that cannot legally change order and be equivalent 2522 p = Pattern.compile("testa\u0308\u0300", Pattern.CANON_EQ); 2523 check(p, "testa\u0308\u0300", true); 2524 check(p, "testa\u0300\u0308", false); 2525 2526 // Marks that can legally change order and be equivalent 2527 p = Pattern.compile("testa\u0308\u0323", Pattern.CANON_EQ); 2528 check(p, "testa\u0308\u0323", true); 2529 check(p, "testa\u0323\u0308", true); 2530 2531 // Test all equivalences of the sequence a\u0308\u0323\u0300 2532 p = Pattern.compile("testa\u0308\u0323\u0300", Pattern.CANON_EQ); 2533 check(p, "testa\u0308\u0323\u0300", true); 2534 check(p, "testa\u0323\u0308\u0300", true); 2535 check(p, "testa\u0308\u0300\u0323", true); 2536 check(p, "test\u00e4\u0323\u0300", true); 2537 check(p, "test\u00e4\u0300\u0323", true); 2538 2539 /* 2540 * The following canonical equivalence tests don't work. Bug id: 4916384. 2541 * 2542 // Decomposed hangul (jamos) 2543 p = Pattern.compile("\u1100\u1161", Pattern.CANON_EQ); 2544 m = p.matcher("\u1100\u1161"); 2545 if (!m.matches()) 2546 failCount++; 2547 2548 m.reset("\uac00"); 2549 if (!m.matches()) 2550 failCount++; 2551 2552 // Composed hangul 2553 p = Pattern.compile("\uac00", Pattern.CANON_EQ); 2554 m = p.matcher("\u1100\u1161"); 2555 if (!m.matches()) 2556 failCount++; 2557 2558 m.reset("\uac00"); 2559 if (!m.matches()) 2560 failCount++; 2561 2562 // Decomposed supplementary outside char classes 2563 p = Pattern.compile("test\ud834\uddbc\ud834\udd6f", Pattern.CANON_EQ); 2564 m = p.matcher("test\ud834\uddc0"); 2565 if (!m.matches()) 2566 failCount++; 2567 2568 m.reset("test\ud834\uddbc\ud834\udd6f"); 2569 if (!m.matches()) 2570 failCount++; 2571 2572 // Composed supplementary outside char classes 2573 p = Pattern.compile("test\ud834\uddc0", Pattern.CANON_EQ); 2574 m.reset("test\ud834\uddbc\ud834\udd6f"); 2575 if (!m.matches()) 2576 failCount++; 2577 2578 m = p.matcher("test\ud834\uddc0"); 2579 if (!m.matches()) 2580 failCount++; 2581 2582 */ 2583 2584 report("Canonical Equivalence"); 2585 } 2586 2587 /** 2588 * A basic sanity test of Matcher.replaceAll(). 2589 */ 2590 private static void globalSubstitute() throws Exception { 2591 // Global substitution with a literal 2592 Pattern p = Pattern.compile("(ab)(c*)"); 2593 Matcher m = p.matcher("abccczzzabcczzzabccc"); 2594 if (!m.replaceAll("test").equals("testzzztestzzztest")) 2595 failCount++; 2596 2597 m.reset("zzzabccczzzabcczzzabccczzz"); 2598 if (!m.replaceAll("test").equals("zzztestzzztestzzztestzzz")) 2599 failCount++; 2600 2601 // Global substitution with groups 2602 m.reset("zzzabccczzzabcczzzabccczzz"); 2603 String result = m.replaceAll("$1"); 2604 if (!result.equals("zzzabzzzabzzzabzzz")) 2605 failCount++; 2606 2607 // Supplementary character test 2608 // Global substitution with a literal 2609 p = Pattern.compile(toSupplementaries("(ab)(c*)")); 2610 m = p.matcher(toSupplementaries("abccczzzabcczzzabccc")); 2611 if (!m.replaceAll(toSupplementaries("test")). 2612 equals(toSupplementaries("testzzztestzzztest"))) 2613 failCount++; 2614 2615 m.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); 2616 if (!m.replaceAll(toSupplementaries("test")). 2617 equals(toSupplementaries("zzztestzzztestzzztestzzz"))) 2618 failCount++; 2619 2620 // Global substitution with groups 2621 m.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); 2622 result = m.replaceAll("$1"); 2623 if (!result.equals(toSupplementaries("zzzabzzzabzzzabzzz"))) 2624 failCount++; 2625 2626 report("Global Substitution"); 2627 } 2628 2629 /** 2630 * Tests the usage of Matcher.appendReplacement() with literal 2631 * and group substitutions. 2632 */ 2633 private static void stringbufferSubstitute() throws Exception { 2634 // SB substitution with literal 2635 String blah = "zzzblahzzz"; 2636 Pattern p = Pattern.compile("blah"); 2637 Matcher m = p.matcher(blah); 2638 StringBuffer result = new StringBuffer(); 2639 try { 2640 m.appendReplacement(result, "blech"); 2641 failCount++; 2642 } catch (IllegalStateException e) { 2643 } 2644 m.find(); 2645 m.appendReplacement(result, "blech"); 2646 if (!result.toString().equals("zzzblech")) 2647 failCount++; 2648 2649 m.appendTail(result); 2650 if (!result.toString().equals("zzzblechzzz")) 2651 failCount++; 2652 2653 // SB substitution with groups 2654 blah = "zzzabcdzzz"; 2655 p = Pattern.compile("(ab)(cd)*"); 2656 m = p.matcher(blah); 2657 result = new StringBuffer(); 2658 try { 2659 m.appendReplacement(result, "$1"); 2660 failCount++; 2661 } catch (IllegalStateException e) { 2662 } 2663 m.find(); 2664 m.appendReplacement(result, "$1"); 2665 if (!result.toString().equals("zzzab")) 2666 failCount++; 2667 2668 m.appendTail(result); 2669 if (!result.toString().equals("zzzabzzz")) 2670 failCount++; 2671 2672 // SB substitution with 3 groups 2673 blah = "zzzabcdcdefzzz"; 2674 p = Pattern.compile("(ab)(cd)*(ef)"); 2675 m = p.matcher(blah); 2676 result = new StringBuffer(); 2677 try { 2678 m.appendReplacement(result, "$1w$2w$3"); 2679 failCount++; 2680 } catch (IllegalStateException e) { 2681 } 2682 m.find(); 2683 m.appendReplacement(result, "$1w$2w$3"); 2684 if (!result.toString().equals("zzzabwcdwef")) 2685 failCount++; 2686 2687 m.appendTail(result); 2688 if (!result.toString().equals("zzzabwcdwefzzz")) 2689 failCount++; 2690 2691 // SB substitution with groups and three matches 2692 // skipping middle match 2693 blah = "zzzabcdzzzabcddzzzabcdzzz"; 2694 p = Pattern.compile("(ab)(cd*)"); 2695 m = p.matcher(blah); 2696 result = new StringBuffer(); 2697 try { 2698 m.appendReplacement(result, "$1"); 2699 failCount++; 2700 } catch (IllegalStateException e) { 2701 } 2702 m.find(); 2703 m.appendReplacement(result, "$1"); 2704 if (!result.toString().equals("zzzab")) 2705 failCount++; 2706 2707 m.find(); 2708 m.find(); 2709 m.appendReplacement(result, "$2"); 2710 if (!result.toString().equals("zzzabzzzabcddzzzcd")) 2711 failCount++; 2712 2713 m.appendTail(result); 2714 if (!result.toString().equals("zzzabzzzabcddzzzcdzzz")) 2715 failCount++; 2716 2717 // Check to make sure escaped $ is ignored 2718 blah = "zzzabcdcdefzzz"; 2719 p = Pattern.compile("(ab)(cd)*(ef)"); 2720 m = p.matcher(blah); 2721 result = new StringBuffer(); 2722 m.find(); 2723 m.appendReplacement(result, "$1w\\$2w$3"); 2724 if (!result.toString().equals("zzzabw$2wef")) 2725 failCount++; 2726 2727 m.appendTail(result); 2728 if (!result.toString().equals("zzzabw$2wefzzz")) 2729 failCount++; 2730 2731 // Check to make sure a reference to nonexistent group causes error 2732 blah = "zzzabcdcdefzzz"; 2733 p = Pattern.compile("(ab)(cd)*(ef)"); 2734 m = p.matcher(blah); 2735 result = new StringBuffer(); 2736 m.find(); 2737 try { 2738 m.appendReplacement(result, "$1w$5w$3"); 2739 failCount++; 2740 } catch (IndexOutOfBoundsException ioobe) { 2741 // Correct result 2742 } 2743 2744 // Check double digit group references 2745 blah = "zzz123456789101112zzz"; 2746 p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)"); 2747 m = p.matcher(blah); 2748 result = new StringBuffer(); 2749 m.find(); 2750 m.appendReplacement(result, "$1w$11w$3"); 2751 if (!result.toString().equals("zzz1w11w3")) 2752 failCount++; 2753 2754 // Check to make sure it backs off $15 to $1 if only three groups 2755 blah = "zzzabcdcdefzzz"; 2756 p = Pattern.compile("(ab)(cd)*(ef)"); 2757 m = p.matcher(blah); 2758 result = new StringBuffer(); 2759 m.find(); 2760 m.appendReplacement(result, "$1w$15w$3"); 2761 if (!result.toString().equals("zzzabwab5wef")) 2762 failCount++; 2763 2764 2765 // Supplementary character test 2766 // SB substitution with literal 2767 blah = toSupplementaries("zzzblahzzz"); 2768 p = Pattern.compile(toSupplementaries("blah")); 2769 m = p.matcher(blah); 2770 result = new StringBuffer(); 2771 try { 2772 m.appendReplacement(result, toSupplementaries("blech")); 2773 failCount++; 2774 } catch (IllegalStateException e) { 2775 } 2776 m.find(); 2777 m.appendReplacement(result, toSupplementaries("blech")); 2778 if (!result.toString().equals(toSupplementaries("zzzblech"))) 2779 failCount++; 2780 2781 m.appendTail(result); 2782 if (!result.toString().equals(toSupplementaries("zzzblechzzz"))) 2783 failCount++; 2784 2785 // SB substitution with groups 2786 blah = toSupplementaries("zzzabcdzzz"); 2787 p = Pattern.compile(toSupplementaries("(ab)(cd)*")); 2788 m = p.matcher(blah); 2789 result = new StringBuffer(); 2790 try { 2791 m.appendReplacement(result, "$1"); 2792 failCount++; 2793 } catch (IllegalStateException e) { 2794 } 2795 m.find(); 2796 m.appendReplacement(result, "$1"); 2797 if (!result.toString().equals(toSupplementaries("zzzab"))) 2798 failCount++; 2799 2800 m.appendTail(result); 2801 if (!result.toString().equals(toSupplementaries("zzzabzzz"))) 2802 failCount++; 2803 2804 // SB substitution with 3 groups 2805 blah = toSupplementaries("zzzabcdcdefzzz"); 2806 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); 2807 m = p.matcher(blah); 2808 result = new StringBuffer(); 2809 try { 2810 m.appendReplacement(result, toSupplementaries("$1w$2w$3")); 2811 failCount++; 2812 } catch (IllegalStateException e) { 2813 } 2814 m.find(); 2815 m.appendReplacement(result, toSupplementaries("$1w$2w$3")); 2816 if (!result.toString().equals(toSupplementaries("zzzabwcdwef"))) 2817 failCount++; 2818 2819 m.appendTail(result); 2820 if (!result.toString().equals(toSupplementaries("zzzabwcdwefzzz"))) 2821 failCount++; 2822 2823 // SB substitution with groups and three matches 2824 // skipping middle match 2825 blah = toSupplementaries("zzzabcdzzzabcddzzzabcdzzz"); 2826 p = Pattern.compile(toSupplementaries("(ab)(cd*)")); 2827 m = p.matcher(blah); 2828 result = new StringBuffer(); 2829 try { 2830 m.appendReplacement(result, "$1"); 2831 failCount++; 2832 } catch (IllegalStateException e) { 2833 } 2834 m.find(); 2835 m.appendReplacement(result, "$1"); 2836 if (!result.toString().equals(toSupplementaries("zzzab"))) 2837 failCount++; 2838 2839 m.find(); 2840 m.find(); 2841 m.appendReplacement(result, "$2"); 2842 if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcd"))) 2843 failCount++; 2844 2845 m.appendTail(result); 2846 if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcdzzz"))) 2847 failCount++; 2848 2849 // Check to make sure escaped $ is ignored 2850 blah = toSupplementaries("zzzabcdcdefzzz"); 2851 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); 2852 m = p.matcher(blah); 2853 result = new StringBuffer(); 2854 m.find(); 2855 m.appendReplacement(result, toSupplementaries("$1w\\$2w$3")); 2856 if (!result.toString().equals(toSupplementaries("zzzabw$2wef"))) 2857 failCount++; 2858 2859 m.appendTail(result); 2860 if (!result.toString().equals(toSupplementaries("zzzabw$2wefzzz"))) 2861 failCount++; 2862 2863 // Check to make sure a reference to nonexistent group causes error 2864 blah = toSupplementaries("zzzabcdcdefzzz"); 2865 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); 2866 m = p.matcher(blah); 2867 result = new StringBuffer(); 2868 m.find(); 2869 try { 2870 m.appendReplacement(result, toSupplementaries("$1w$5w$3")); 2871 failCount++; 2872 } catch (IndexOutOfBoundsException ioobe) { 2873 // Correct result 2874 } 2875 2876 // Check double digit group references 2877 blah = toSupplementaries("zzz123456789101112zzz"); 2878 p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)"); 2879 m = p.matcher(blah); 2880 result = new StringBuffer(); 2881 m.find(); 2882 m.appendReplacement(result, toSupplementaries("$1w$11w$3")); 2883 if (!result.toString().equals(toSupplementaries("zzz1w11w3"))) 2884 failCount++; 2885 2886 // Check to make sure it backs off $15 to $1 if only three groups 2887 blah = toSupplementaries("zzzabcdcdefzzz"); 2888 p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); 2889 m = p.matcher(blah); 2890 result = new StringBuffer(); 2891 m.find(); 2892 m.appendReplacement(result, toSupplementaries("$1w$15w$3")); 2893 if (!result.toString().equals(toSupplementaries("zzzabwab5wef"))) 2894 failCount++; 2895 2896 // Check nothing has been appended into the output buffer if 2897 // the replacement string triggers IllegalArgumentException. 2898 p = Pattern.compile("(abc)"); 2899 m = p.matcher("abcd"); 2900 result = new StringBuffer(); 2901 m.find(); 2902 try { 2903 m.appendReplacement(result, ("xyz$g")); 2904 failCount++; 2905 } catch (IllegalArgumentException iae) { 2906 if (result.length() != 0) 2907 failCount++; 2908 } 2909 2910 report("SB Substitution"); 2911 } 2912 2913 /* 2914 * 5 groups of characters are created to make a substitution string. 2915 * A base string will be created including random lead chars, the 2916 * substitution string, and random trailing chars. 2917 * A pattern containing the 5 groups is searched for and replaced with: 2918 * random group + random string + random group. 2919 * The results are checked for correctness. 2920 */ 2921 private static void substitutionBasher() { 2922 for (int runs = 0; runs<1000; runs++) { 2923 // Create a base string to work in 2924 int leadingChars = generator.nextInt(10); 2925 StringBuffer baseBuffer = new StringBuffer(100); 2926 String leadingString = getRandomAlphaString(leadingChars); 2927 baseBuffer.append(leadingString); 2928 2929 // Create 5 groups of random number of random chars 2930 // Create the string to substitute 2931 // Create the pattern string to search for 2932 StringBuffer bufferToSub = new StringBuffer(25); 2933 StringBuffer bufferToPat = new StringBuffer(50); 2934 String[] groups = new String[5]; 2935 for(int i=0; i<5; i++) { 2936 int aGroupSize = generator.nextInt(5)+1; 2937 groups[i] = getRandomAlphaString(aGroupSize); 2938 bufferToSub.append(groups[i]); 2939 bufferToPat.append('('); 2940 bufferToPat.append(groups[i]); 2941 bufferToPat.append(')'); 2942 } 2943 String stringToSub = bufferToSub.toString(); 2944 String pattern = bufferToPat.toString(); 2945 2946 // Place sub string into working string at random index 2947 baseBuffer.append(stringToSub); 2948 2949 // Append random chars to end 2950 int trailingChars = generator.nextInt(10); 2951 String trailingString = getRandomAlphaString(trailingChars); 2952 baseBuffer.append(trailingString); 2953 String baseString = baseBuffer.toString(); 2954 2955 // Create test pattern and matcher 2956 Pattern p = Pattern.compile(pattern); 2957 Matcher m = p.matcher(baseString); 2958 2959 // Reject candidate if pattern happens to start early 2960 m.find(); 2961 if (m.start() < leadingChars) 2962 continue; 2963 2964 // Reject candidate if more than one match 2965 if (m.find()) 2966 continue; 2967 2968 // Construct a replacement string with : 2969 // random group + random string + random group 2970 StringBuffer bufferToRep = new StringBuffer(); 2971 int groupIndex1 = generator.nextInt(5); 2972 bufferToRep.append("$" + (groupIndex1 + 1)); 2973 String randomMidString = getRandomAlphaString(5); 2974 bufferToRep.append(randomMidString); 2975 int groupIndex2 = generator.nextInt(5); 2976 bufferToRep.append("$" + (groupIndex2 + 1)); 2977 String replacement = bufferToRep.toString(); 2978 2979 // Do the replacement 2980 String result = m.replaceAll(replacement); 2981 2982 // Construct expected result 2983 StringBuffer bufferToRes = new StringBuffer(); 2984 bufferToRes.append(leadingString); 2985 bufferToRes.append(groups[groupIndex1]); 2986 bufferToRes.append(randomMidString); 2987 bufferToRes.append(groups[groupIndex2]); 2988 bufferToRes.append(trailingString); 2989 String expectedResult = bufferToRes.toString(); 2990 2991 // Check results 2992 if (!result.equals(expectedResult)) 2993 failCount++; 2994 } 2995 2996 report("Substitution Basher"); 2997 } 2998 2999 /** 3000 * Checks the handling of some escape sequences that the Pattern 3001 * class should process instead of the java compiler. These are 3002 * not in the file because the escapes should be be processed 3003 * by the Pattern class when the regex is compiled. 3004 */ 3005 private static void escapes() throws Exception { 3006 Pattern p = Pattern.compile("\\043"); 3007 Matcher m = p.matcher("#"); 3008 if (!m.find()) 3009 failCount++; 3010 3011 p = Pattern.compile("\\x23"); 3012 m = p.matcher("#"); 3013 if (!m.find()) 3014 failCount++; 3015 3016 p = Pattern.compile("\\u0023"); 3017 m = p.matcher("#"); 3018 if (!m.find()) 3019 failCount++; 3020 3021 report("Escape sequences"); 3022 } 3023 3024 /** 3025 * Checks the handling of blank input situations. These 3026 * tests are incompatible with my test file format. 3027 */ 3028 private static void blankInput() throws Exception { 3029 Pattern p = Pattern.compile("abc", Pattern.CASE_INSENSITIVE); 3030 Matcher m = p.matcher(""); 3031 if (m.find()) 3032 failCount++; 3033 3034 p = Pattern.compile("a*", Pattern.CASE_INSENSITIVE); 3035 m = p.matcher(""); 3036 if (!m.find()) 3037 failCount++; 3038 3039 p = Pattern.compile("abc"); 3040 m = p.matcher(""); 3041 if (m.find()) 3042 failCount++; 3043 3044 p = Pattern.compile("a*"); 3045 m = p.matcher(""); 3046 if (!m.find()) 3047 failCount++; 3048 3049 report("Blank input"); 3050 } 3051 3052 /** 3053 * Tests the Boyer-Moore pattern matching of a character sequence 3054 * on randomly generated patterns. 3055 */ 3056 private static void bm() throws Exception { 3057 doBnM('a'); 3058 report("Boyer Moore (ASCII)"); 3059 3060 doBnM(Character.MIN_SUPPLEMENTARY_CODE_POINT - 10); 3061 report("Boyer Moore (Supplementary)"); 3062 } 3063 3064 private static void doBnM(int baseCharacter) throws Exception { 3065 int achar=0; 3066 3067 for (int i=0; i<100; i++) { 3068 // Create a short pattern to search for 3069 int patternLength = generator.nextInt(7) + 4; 3070 StringBuffer patternBuffer = new StringBuffer(patternLength); 3071 for (int x=0; x<patternLength; x++) { 3072 int ch = baseCharacter + generator.nextInt(26); 3073 if (Character.isSupplementaryCodePoint(ch)) { 3074 patternBuffer.append(Character.toChars(ch)); 3075 } else { 3076 patternBuffer.append((char)ch); 3077 } 3078 } 3079 String pattern = patternBuffer.toString(); 3080 Pattern p = Pattern.compile(pattern); 3081 3082 // Create a buffer with random ASCII chars that does 3083 // not match the sample 3084 String toSearch = null; 3085 StringBuffer s = null; 3086 Matcher m = p.matcher(""); 3087 do { 3088 s = new StringBuffer(100); 3089 for (int x=0; x<100; x++) { 3090 int ch = baseCharacter + generator.nextInt(26); 3091 if (Character.isSupplementaryCodePoint(ch)) { 3092 s.append(Character.toChars(ch)); 3093 } else { 3094 s.append((char)ch); 3095 } 3096 } 3097 toSearch = s.toString(); 3098 m.reset(toSearch); 3099 } while (m.find()); 3100 3101 // Insert the pattern at a random spot 3102 int insertIndex = generator.nextInt(99); 3103 if (Character.isLowSurrogate(s.charAt(insertIndex))) 3104 insertIndex++; 3105 s = s.insert(insertIndex, pattern); 3106 toSearch = s.toString(); 3107 3108 // Make sure that the pattern is found 3109 m.reset(toSearch); 3110 if (!m.find()) 3111 failCount++; 3112 3113 // Make sure that the match text is the pattern 3114 if (!m.group().equals(pattern)) 3115 failCount++; 3116 3117 // Make sure match occured at insertion point 3118 if (m.start() != insertIndex) 3119 failCount++; 3120 } 3121 } 3122 3123 /** 3124 * Tests the matching of slices on randomly generated patterns. 3125 * The Boyer-Moore optimization is not done on these patterns 3126 * because it uses unicode case folding. 3127 */ 3128 private static void slice() throws Exception { 3129 doSlice(Character.MAX_VALUE); 3130 report("Slice"); 3131 3132 doSlice(Character.MAX_CODE_POINT); 3133 report("Slice (Supplementary)"); 3134 } 3135 3136 private static void doSlice(int maxCharacter) throws Exception { 3137 Random generator = new Random(); 3138 int achar=0; 3139 3140 for (int i=0; i<100; i++) { 3141 // Create a short pattern to search for 3142 int patternLength = generator.nextInt(7) + 4; 3143 StringBuffer patternBuffer = new StringBuffer(patternLength); 3144 for (int x=0; x<patternLength; x++) { 3145 int randomChar = 0; 3146 while (!Character.isLetterOrDigit(randomChar)) 3147 randomChar = generator.nextInt(maxCharacter); 3148 if (Character.isSupplementaryCodePoint(randomChar)) { 3149 patternBuffer.append(Character.toChars(randomChar)); 3150 } else { 3151 patternBuffer.append((char) randomChar); 3152 } 3153 } 3154 String pattern = patternBuffer.toString(); 3155 Pattern p = Pattern.compile(pattern, Pattern.UNICODE_CASE); 3156 3157 // Create a buffer with random chars that does not match the sample 3158 String toSearch = null; 3159 StringBuffer s = null; 3160 Matcher m = p.matcher(""); 3161 do { 3162 s = new StringBuffer(100); 3163 for (int x=0; x<100; x++) { 3164 int randomChar = 0; 3165 while (!Character.isLetterOrDigit(randomChar)) 3166 randomChar = generator.nextInt(maxCharacter); 3167 if (Character.isSupplementaryCodePoint(randomChar)) { 3168 s.append(Character.toChars(randomChar)); 3169 } else { 3170 s.append((char) randomChar); 3171 } 3172 } 3173 toSearch = s.toString(); 3174 m.reset(toSearch); 3175 } while (m.find()); 3176 3177 // Insert the pattern at a random spot 3178 int insertIndex = generator.nextInt(99); 3179 if (Character.isLowSurrogate(s.charAt(insertIndex))) 3180 insertIndex++; 3181 s = s.insert(insertIndex, pattern); 3182 toSearch = s.toString(); 3183 3184 // Make sure that the pattern is found 3185 m.reset(toSearch); 3186 if (!m.find()) 3187 failCount++; 3188 3189 // Make sure that the match text is the pattern 3190 if (!m.group().equals(pattern)) 3191 failCount++; 3192 3193 // Make sure match occured at insertion point 3194 if (m.start() != insertIndex) 3195 failCount++; 3196 } 3197 } 3198 3199 private static void explainFailure(String pattern, String data, 3200 String expected, String actual) { 3201 System.err.println("----------------------------------------"); 3202 System.err.println("Pattern = "+pattern); 3203 System.err.println("Data = "+data); 3204 System.err.println("Expected = " + expected); 3205 System.err.println("Actual = " + actual); 3206 } 3207 3208 private static void explainFailure(String pattern, String data, 3209 Throwable t) { 3210 System.err.println("----------------------------------------"); 3211 System.err.println("Pattern = "+pattern); 3212 System.err.println("Data = "+data); 3213 t.printStackTrace(System.err); 3214 } 3215 3216 // Testing examples from a file 3217 3218 /** 3219 * Goes through the file "TestCases.txt" and creates many patterns 3220 * described in the file, matching the patterns against input lines in 3221 * the file, and comparing the results against the correct results 3222 * also found in the file. The file format is described in comments 3223 * at the head of the file. 3224 */ 3225 private static void processFile(String fileName) throws Exception { 3226 File testCases = new File(System.getProperty("test.src", "."), 3227 fileName); 3228 FileInputStream in = new FileInputStream(testCases); 3229 BufferedReader r = new BufferedReader(new InputStreamReader(in)); 3230 3231 // Process next test case. 3232 String aLine; 3233 while((aLine = r.readLine()) != null) { 3234 // Read a line for pattern 3235 String patternString = grabLine(r); 3236 Pattern p = null; 3237 try { 3238 p = compileTestPattern(patternString); 3239 } catch (PatternSyntaxException e) { 3240 String dataString = grabLine(r); 3241 String expectedResult = grabLine(r); 3242 if (expectedResult.startsWith("error")) 3243 continue; 3244 explainFailure(patternString, dataString, e); 3245 failCount++; 3246 continue; 3247 } 3248 3249 // Read a line for input string 3250 String dataString = grabLine(r); 3251 Matcher m = p.matcher(dataString); 3252 StringBuffer result = new StringBuffer(); 3253 3254 // Check for IllegalStateExceptions before a match 3255 failCount += preMatchInvariants(m); 3256 3257 boolean found = m.find(); 3258 3259 if (found) 3260 failCount += postTrueMatchInvariants(m); 3261 else 3262 failCount += postFalseMatchInvariants(m); 3263 3264 if (found) { 3265 result.append("true "); 3266 result.append(m.group(0) + " "); 3267 } else { 3268 result.append("false "); 3269 } 3270 3271 result.append(m.groupCount()); 3272 3273 if (found) { 3274 for (int i=1; i<m.groupCount()+1; i++) 3275 if (m.group(i) != null) 3276 result.append(" " +m.group(i)); 3277 } 3278 3279 // Read a line for the expected result 3280 String expectedResult = grabLine(r); 3281 3282 if (!result.toString().equals(expectedResult)) { 3283 explainFailure(patternString, dataString, expectedResult, result.toString()); 3284 failCount++; 3285 } 3286 } 3287 3288 report(fileName); 3289 } 3290 3291 private static int preMatchInvariants(Matcher m) { 3292 int failCount = 0; 3293 try { 3294 m.start(); 3295 failCount++; 3296 } catch (IllegalStateException ise) {} 3297 try { 3298 m.end(); 3299 failCount++; 3300 } catch (IllegalStateException ise) {} 3301 try { 3302 m.group(); 3303 failCount++; 3304 } catch (IllegalStateException ise) {} 3305 return failCount; 3306 } 3307 3308 private static int postFalseMatchInvariants(Matcher m) { 3309 int failCount = 0; 3310 try { 3311 m.group(); 3312 failCount++; 3313 } catch (IllegalStateException ise) {} 3314 try { 3315 m.start(); 3316 failCount++; 3317 } catch (IllegalStateException ise) {} 3318 try { 3319 m.end(); 3320 failCount++; 3321 } catch (IllegalStateException ise) {} 3322 return failCount; 3323 } 3324 3325 private static int postTrueMatchInvariants(Matcher m) { 3326 int failCount = 0; 3327 //assert(m.start() = m.start(0); 3328 if (m.start() != m.start(0)) 3329 failCount++; 3330 //assert(m.end() = m.end(0); 3331 if (m.start() != m.start(0)) 3332 failCount++; 3333 //assert(m.group() = m.group(0); 3334 if (!m.group().equals(m.group(0))) 3335 failCount++; 3336 try { 3337 m.group(50); 3338 failCount++; 3339 } catch (IndexOutOfBoundsException ise) {} 3340 3341 return failCount; 3342 } 3343 3344 private static Pattern compileTestPattern(String patternString) { 3345 if (!patternString.startsWith("'")) { 3346 return Pattern.compile(patternString); 3347 } 3348 3349 int break1 = patternString.lastIndexOf("'"); 3350 String flagString = patternString.substring( 3351 break1+1, patternString.length()); 3352 patternString = patternString.substring(1, break1); 3353 3354 if (flagString.equals("i")) 3355 return Pattern.compile(patternString, Pattern.CASE_INSENSITIVE); 3356 3357 if (flagString.equals("m")) 3358 return Pattern.compile(patternString, Pattern.MULTILINE); 3359 3360 return Pattern.compile(patternString); 3361 } 3362 3363 /** 3364 * Reads a line from the input file. Keeps reading lines until a non 3365 * empty non comment line is read. If the line contains a \n then 3366 * these two characters are replaced by a newline char. If a \\uxxxx 3367 * sequence is read then the sequence is replaced by the unicode char. 3368 */ 3369 private static String grabLine(BufferedReader r) throws Exception { 3370 int index = 0; 3371 String line = r.readLine(); 3372 while (line.startsWith("//") || line.length() < 1) 3373 line = r.readLine(); 3374 while ((index = line.indexOf("\\n")) != -1) { 3375 StringBuffer temp = new StringBuffer(line); 3376 temp.replace(index, index+2, "\n"); 3377 line = temp.toString(); 3378 } 3379 while ((index = line.indexOf("\\u")) != -1) { 3380 StringBuffer temp = new StringBuffer(line); 3381 String value = temp.substring(index+2, index+6); 3382 char aChar = (char)Integer.parseInt(value, 16); 3383 String unicodeChar = "" + aChar; 3384 temp.replace(index, index+6, unicodeChar); 3385 line = temp.toString(); 3386 } 3387 3388 return line; 3389 } 3390 3391 private static void check(Pattern p, String s, String g, String expected) { 3392 Matcher m = p.matcher(s); 3393 m.find(); 3394 if (!m.group(g).equals(expected) || 3395 s.charAt(m.start(g)) != expected.charAt(0) || 3396 s.charAt(m.end(g) - 1) != expected.charAt(expected.length() - 1)) 3397 failCount++; 3398 } 3399 3400 private static void checkReplaceFirst(String p, String s, String r, String expected) 3401 { 3402 if (!expected.equals(Pattern.compile(p) 3403 .matcher(s) 3404 .replaceFirst(r))) 3405 failCount++; 3406 } 3407 3408 private static void checkReplaceAll(String p, String s, String r, String expected) 3409 { 3410 if (!expected.equals(Pattern.compile(p) 3411 .matcher(s) 3412 .replaceAll(r))) 3413 failCount++; 3414 } 3415 3416 private static void checkExpectedFail(String p) { 3417 try { 3418 Pattern.compile(p); 3419 } catch (PatternSyntaxException pse) { 3420 //pse.printStackTrace(); 3421 return; 3422 } 3423 failCount++; 3424 } 3425 3426 private static void checkExpectedIAE(Matcher m, String g) { 3427 m.find(); 3428 try { 3429 m.group(g); 3430 } catch (IllegalArgumentException x) { 3431 //iae.printStackTrace(); 3432 try { 3433 m.start(g); 3434 } catch (IllegalArgumentException xx) { 3435 try { 3436 m.start(g); 3437 } catch (IllegalArgumentException xxx) { 3438 return; 3439 } 3440 } 3441 } 3442 failCount++; 3443 } 3444 3445 private static void checkExpectedNPE(Matcher m) { 3446 m.find(); 3447 try { 3448 m.group(null); 3449 } catch (NullPointerException x) { 3450 try { 3451 m.start(null); 3452 } catch (NullPointerException xx) { 3453 try { 3454 m.end(null); 3455 } catch (NullPointerException xxx) { 3456 return; 3457 } 3458 } 3459 } 3460 failCount++; 3461 } 3462 3463 private static void namedGroupCaptureTest() throws Exception { 3464 check(Pattern.compile("x+(?<gname>y+)z+"), 3465 "xxxyyyzzz", 3466 "gname", 3467 "yyy"); 3468 3469 check(Pattern.compile("x+(?<gname8>y+)z+"), 3470 "xxxyyyzzz", 3471 "gname8", 3472 "yyy"); 3473 3474 //backref 3475 Pattern pattern = Pattern.compile("(a*)bc\\1"); 3476 check(pattern, "zzzaabcazzz", true); // found "abca" 3477 3478 check(Pattern.compile("(?<gname>a*)bc\\k<gname>"), 3479 "zzzaabcaazzz", true); 3480 3481 check(Pattern.compile("(?<gname>abc)(def)\\k<gname>"), 3482 "abcdefabc", true); 3483 3484 check(Pattern.compile("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(?<gname>k)\\k<gname>"), 3485 "abcdefghijkk", true); 3486 3487 // Supplementary character tests 3488 check(Pattern.compile("(?<gname>" + toSupplementaries("a*)bc") + "\\k<gname>"), 3489 toSupplementaries("zzzaabcazzz"), true); 3490 3491 check(Pattern.compile("(?<gname>" + toSupplementaries("a*)bc") + "\\k<gname>"), 3492 toSupplementaries("zzzaabcaazzz"), true); 3493 3494 check(Pattern.compile("(?<gname>" + toSupplementaries("abc)(def)") + "\\k<gname>"), 3495 toSupplementaries("abcdefabc"), true); 3496 3497 check(Pattern.compile(toSupplementaries("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)") + 3498 "(?<gname>" + 3499 toSupplementaries("k)") + "\\k<gname>"), 3500 toSupplementaries("abcdefghijkk"), true); 3501 3502 check(Pattern.compile("x+(?<gname>y+)z+\\k<gname>"), 3503 "xxxyyyzzzyyy", 3504 "gname", 3505 "yyy"); 3506 3507 //replaceFirst/All 3508 checkReplaceFirst("(?<gn>ab)(c*)", 3509 "abccczzzabcczzzabccc", 3510 "${gn}", 3511 "abzzzabcczzzabccc"); 3512 3513 checkReplaceAll("(?<gn>ab)(c*)", 3514 "abccczzzabcczzzabccc", 3515 "${gn}", 3516 "abzzzabzzzab"); 3517 3518 3519 checkReplaceFirst("(?<gn>ab)(c*)", 3520 "zzzabccczzzabcczzzabccczzz", 3521 "${gn}", 3522 "zzzabzzzabcczzzabccczzz"); 3523 3524 checkReplaceAll("(?<gn>ab)(c*)", 3525 "zzzabccczzzabcczzzabccczzz", 3526 "${gn}", 3527 "zzzabzzzabzzzabzzz"); 3528 3529 checkReplaceFirst("(?<gn1>ab)(?<gn2>c*)", 3530 "zzzabccczzzabcczzzabccczzz", 3531 "${gn2}", 3532 "zzzccczzzabcczzzabccczzz"); 3533 3534 checkReplaceAll("(?<gn1>ab)(?<gn2>c*)", 3535 "zzzabccczzzabcczzzabccczzz", 3536 "${gn2}", 3537 "zzzccczzzcczzzccczzz"); 3538 3539 //toSupplementaries("(ab)(c*)")); 3540 checkReplaceFirst("(?<gn1>" + toSupplementaries("ab") + 3541 ")(?<gn2>" + toSupplementaries("c") + "*)", 3542 toSupplementaries("abccczzzabcczzzabccc"), 3543 "${gn1}", 3544 toSupplementaries("abzzzabcczzzabccc")); 3545 3546 3547 checkReplaceAll("(?<gn1>" + toSupplementaries("ab") + 3548 ")(?<gn2>" + toSupplementaries("c") + "*)", 3549 toSupplementaries("abccczzzabcczzzabccc"), 3550 "${gn1}", 3551 toSupplementaries("abzzzabzzzab")); 3552 3553 checkReplaceFirst("(?<gn1>" + toSupplementaries("ab") + 3554 ")(?<gn2>" + toSupplementaries("c") + "*)", 3555 toSupplementaries("abccczzzabcczzzabccc"), 3556 "${gn2}", 3557 toSupplementaries("ccczzzabcczzzabccc")); 3558 3559 3560 checkReplaceAll("(?<gn1>" + toSupplementaries("ab") + 3561 ")(?<gn2>" + toSupplementaries("c") + "*)", 3562 toSupplementaries("abccczzzabcczzzabccc"), 3563 "${gn2}", 3564 toSupplementaries("ccczzzcczzzccc")); 3565 3566 checkReplaceFirst("(?<dog>Dog)AndCat", 3567 "zzzDogAndCatzzzDogAndCatzzz", 3568 "${dog}", 3569 "zzzDogzzzDogAndCatzzz"); 3570 3571 3572 checkReplaceAll("(?<dog>Dog)AndCat", 3573 "zzzDogAndCatzzzDogAndCatzzz", 3574 "${dog}", 3575 "zzzDogzzzDogzzz"); 3576 3577 // backref in Matcher & String 3578 if (!"abcdefghij".replaceFirst("cd(?<gn>ef)gh", "${gn}").equals("abefij") || 3579 !"abbbcbdbefgh".replaceAll("(?<gn>[a-e])b", "${gn}").equals("abcdefgh")) 3580 failCount++; 3581 3582 // negative 3583 checkExpectedFail("(?<groupnamehasnoascii.in>abc)(def)"); 3584 checkExpectedFail("(?<groupnamehasnoascii_in>abc)(def)"); 3585 checkExpectedFail("(?<6groupnamestartswithdigit>abc)(def)"); 3586 checkExpectedFail("(?<gname>abc)(def)\\k<gnameX>"); 3587 checkExpectedFail("(?<gname>abc)(?<gname>def)\\k<gnameX>"); 3588 checkExpectedIAE(Pattern.compile("(?<gname>abc)(def)").matcher("abcdef"), 3589 "gnameX"); 3590 checkExpectedNPE(Pattern.compile("(?<gname>abc)(def)").matcher("abcdef")); 3591 report("NamedGroupCapture"); 3592 } 3593 3594 // This is for bug 6969132 3595 private static void nonBmpClassComplementTest() throws Exception { 3596 Pattern p = Pattern.compile("\\P{Lu}"); 3597 Matcher m = p.matcher(new String(new int[] {0x1d400}, 0, 1)); 3598 if (m.find() && m.start() == 1) 3599 failCount++; 3600 3601 // from a unicode category 3602 p = Pattern.compile("\\P{Lu}"); 3603 m = p.matcher(new String(new int[] {0x1d400}, 0, 1)); 3604 if (m.find()) 3605 failCount++; 3606 if (!m.hitEnd()) 3607 failCount++; 3608 3609 // block 3610 p = Pattern.compile("\\P{InMathematicalAlphanumericSymbols}"); 3611 m = p.matcher(new String(new int[] {0x1d400}, 0, 1)); 3612 if (m.find() && m.start() == 1) 3613 failCount++; 3614 3615 report("NonBmpClassComplement"); 3616 } 3617 3618 private static void unicodePropertiesTest() throws Exception { 3619 // different forms 3620 if (!Pattern.compile("\\p{IsLu}").matcher("A").matches() || 3621 !Pattern.compile("\\p{Lu}").matcher("A").matches() || 3622 !Pattern.compile("\\p{gc=Lu}").matcher("A").matches() || 3623 !Pattern.compile("\\p{general_category=Lu}").matcher("A").matches() || 3624 !Pattern.compile("\\p{IsLatin}").matcher("B").matches() || 3625 !Pattern.compile("\\p{sc=Latin}").matcher("B").matches() || 3626 !Pattern.compile("\\p{script=Latin}").matcher("B").matches() || 3627 !Pattern.compile("\\p{InBasicLatin}").matcher("c").matches() || 3628 !Pattern.compile("\\p{blk=BasicLatin}").matcher("c").matches() || 3629 !Pattern.compile("\\p{block=BasicLatin}").matcher("c").matches()) 3630 failCount++; 3631 3632 Matcher common = Pattern.compile("\\p{script=Common}").matcher(""); 3633 Matcher unknown = Pattern.compile("\\p{IsUnknown}").matcher(""); 3634 Matcher lastSM = common; 3635 Character.UnicodeScript lastScript = Character.UnicodeScript.of(0); 3636 3637 Matcher latin = Pattern.compile("\\p{block=basic_latin}").matcher(""); 3638 Matcher greek = Pattern.compile("\\p{InGreek}").matcher(""); 3639 Matcher lastBM = latin; 3640 Character.UnicodeBlock lastBlock = Character.UnicodeBlock.of(0); 3641 3642 for (int cp = 1; cp < Character.MAX_CODE_POINT; cp++) { 3643 if (cp >= 0x30000 && (cp & 0x70) == 0){ 3644 continue; // only pick couple code points, they are the same 3645 } 3646 3647 // Unicode Script 3648 Character.UnicodeScript script = Character.UnicodeScript.of(cp); 3649 Matcher m; 3650 String str = new String(Character.toChars(cp)); 3651 if (script == lastScript) { 3652 m = lastSM; 3653 m.reset(str); 3654 } else { 3655 m = Pattern.compile("\\p{Is" + script.name() + "}").matcher(str); 3656 } 3657 if (!m.matches()) { 3658 failCount++; 3659 } 3660 Matcher other = (script == Character.UnicodeScript.COMMON)? unknown : common; 3661 other.reset(str); 3662 if (other.matches()) { 3663 failCount++; 3664 } 3665 lastSM = m; 3666 lastScript = script; 3667 3668 // Unicode Block 3669 Character.UnicodeBlock block = Character.UnicodeBlock.of(cp); 3670 if (block == null) { 3671 //System.out.printf("Not a Block: cp=%x%n", cp); 3672 continue; 3673 } 3674 if (block == lastBlock) { 3675 m = lastBM; 3676 m.reset(str); 3677 } else { 3678 m = Pattern.compile("\\p{block=" + block.toString() + "}").matcher(str); 3679 } 3680 if (!m.matches()) { 3681 failCount++; 3682 } 3683 other = (block == Character.UnicodeBlock.BASIC_LATIN)? greek : latin; 3684 other.reset(str); 3685 if (other.matches()) { 3686 failCount++; 3687 } 3688 lastBM = m; 3689 lastBlock = block; 3690 } 3691 report("unicodeProperties"); 3692 } 3693 3694 private static void unicodeHexNotationTest() throws Exception { 3695 3696 // negative 3697 checkExpectedFail("\\x{-23}"); 3698 checkExpectedFail("\\x{110000}"); 3699 checkExpectedFail("\\x{}"); 3700 checkExpectedFail("\\x{AB[ef]"); 3701 3702 // codepoint 3703 check("^\\x{1033c}$", "\uD800\uDF3C", true); 3704 check("^\\xF0\\x90\\x8C\\xBC$", "\uD800\uDF3C", false); 3705 check("^\\x{D800}\\x{DF3c}+$", "\uD800\uDF3C", false); 3706 check("^\\xF0\\x90\\x8C\\xBC$", "\uD800\uDF3C", false); 3707 3708 // in class 3709 check("^[\\x{D800}\\x{DF3c}]+$", "\uD800\uDF3C", false); 3710 check("^[\\xF0\\x90\\x8C\\xBC]+$", "\uD800\uDF3C", false); 3711 check("^[\\x{D800}\\x{DF3C}]+$", "\uD800\uDF3C", false); 3712 check("^[\\x{DF3C}\\x{D800}]+$", "\uD800\uDF3C", false); 3713 check("^[\\x{D800}\\x{DF3C}]+$", "\uDF3C\uD800", true); 3714 check("^[\\x{DF3C}\\x{D800}]+$", "\uDF3C\uD800", true); 3715 3716 for (int cp = 0; cp <= 0x10FFFF; cp++) { 3717 String s = "A" + new String(Character.toChars(cp)) + "B"; 3718 String hexUTF16 = (cp <= 0xFFFF)? String.format("\\u%04x", cp) 3719 : String.format("\\u%04x\\u%04x", 3720 (int) Character.toChars(cp)[0], 3721 (int) Character.toChars(cp)[1]); 3722 String hexCodePoint = "\\x{" + Integer.toHexString(cp) + "}"; 3723 if (!Pattern.matches("A" + hexUTF16 + "B", s)) 3724 failCount++; 3725 if (!Pattern.matches("A[" + hexUTF16 + "]B", s)) 3726 failCount++; 3727 if (!Pattern.matches("A" + hexCodePoint + "B", s)) 3728 failCount++; 3729 if (!Pattern.matches("A[" + hexCodePoint + "]B", s)) 3730 failCount++; 3731 } 3732 report("unicodeHexNotation"); 3733 } 3734 3735 private static void unicodeClassesTest() throws Exception { 3736 3737 Matcher lower = Pattern.compile("\\p{Lower}").matcher(""); 3738 Matcher upper = Pattern.compile("\\p{Upper}").matcher(""); 3739 Matcher ASCII = Pattern.compile("\\p{ASCII}").matcher(""); 3740 Matcher alpha = Pattern.compile("\\p{Alpha}").matcher(""); 3741 Matcher digit = Pattern.compile("\\p{Digit}").matcher(""); 3742 Matcher alnum = Pattern.compile("\\p{Alnum}").matcher(""); 3743 Matcher punct = Pattern.compile("\\p{Punct}").matcher(""); 3744 Matcher graph = Pattern.compile("\\p{Graph}").matcher(""); 3745 Matcher print = Pattern.compile("\\p{Print}").matcher(""); 3746 Matcher blank = Pattern.compile("\\p{Blank}").matcher(""); 3747 Matcher cntrl = Pattern.compile("\\p{Cntrl}").matcher(""); 3748 Matcher xdigit = Pattern.compile("\\p{XDigit}").matcher(""); 3749 Matcher space = Pattern.compile("\\p{Space}").matcher(""); 3750 Matcher bound = Pattern.compile("\\b").matcher(""); 3751 Matcher word = Pattern.compile("\\w++").matcher(""); 3752 // UNICODE_CHARACTER_CLASS 3753 Matcher lowerU = Pattern.compile("\\p{Lower}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3754 Matcher upperU = Pattern.compile("\\p{Upper}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3755 Matcher ASCIIU = Pattern.compile("\\p{ASCII}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3756 Matcher alphaU = Pattern.compile("\\p{Alpha}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3757 Matcher digitU = Pattern.compile("\\p{Digit}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3758 Matcher alnumU = Pattern.compile("\\p{Alnum}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3759 Matcher punctU = Pattern.compile("\\p{Punct}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3760 Matcher graphU = Pattern.compile("\\p{Graph}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3761 Matcher printU = Pattern.compile("\\p{Print}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3762 Matcher blankU = Pattern.compile("\\p{Blank}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3763 Matcher cntrlU = Pattern.compile("\\p{Cntrl}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3764 Matcher xdigitU = Pattern.compile("\\p{XDigit}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3765 Matcher spaceU = Pattern.compile("\\p{Space}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3766 Matcher boundU = Pattern.compile("\\b", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3767 Matcher wordU = Pattern.compile("\\w", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3768 // embedded flag (?U) 3769 Matcher lowerEU = Pattern.compile("(?U)\\p{Lower}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3770 Matcher graphEU = Pattern.compile("(?U)\\p{Graph}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3771 Matcher wordEU = Pattern.compile("(?U)\\w", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3772 3773 Matcher bwb = Pattern.compile("\\b\\w\\b").matcher(""); 3774 Matcher bwbU = Pattern.compile("\\b\\w++\\b", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3775 Matcher bwbEU = Pattern.compile("(?U)\\b\\w++\\b", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); 3776 // properties 3777 Matcher lowerP = Pattern.compile("\\p{IsLowerCase}").matcher(""); 3778 Matcher upperP = Pattern.compile("\\p{IsUpperCase}").matcher(""); 3779 Matcher titleP = Pattern.compile("\\p{IsTitleCase}").matcher(""); 3780 Matcher letterP = Pattern.compile("\\p{IsLetter}").matcher(""); 3781 Matcher alphaP = Pattern.compile("\\p{IsAlphabetic}").matcher(""); 3782 Matcher ideogP = Pattern.compile("\\p{IsIdeographic}").matcher(""); 3783 Matcher cntrlP = Pattern.compile("\\p{IsControl}").matcher(""); 3784 Matcher spaceP = Pattern.compile("\\p{IsWhiteSpace}").matcher(""); 3785 Matcher definedP = Pattern.compile("\\p{IsAssigned}").matcher(""); 3786 Matcher nonCCPP = Pattern.compile("\\p{IsNoncharacterCodePoint}").matcher(""); 3787 Matcher joinCrtl = Pattern.compile("\\p{IsJoinControl}").matcher(""); 3788 3789 // javaMethod 3790 Matcher lowerJ = Pattern.compile("\\p{javaLowerCase}").matcher(""); 3791 Matcher upperJ = Pattern.compile("\\p{javaUpperCase}").matcher(""); 3792 Matcher alphaJ = Pattern.compile("\\p{javaAlphabetic}").matcher(""); 3793 Matcher ideogJ = Pattern.compile("\\p{javaIdeographic}").matcher(""); 3794 3795 for (int cp = 1; cp < 0x30000; cp++) { 3796 String str = new String(Character.toChars(cp)); 3797 int type = Character.getType(cp); 3798 if (// lower 3799 POSIX_ASCII.isLower(cp) != lower.reset(str).matches() || 3800 Character.isLowerCase(cp) != lowerU.reset(str).matches() || 3801 Character.isLowerCase(cp) != lowerP.reset(str).matches() || 3802 Character.isLowerCase(cp) != lowerEU.reset(str).matches()|| 3803 Character.isLowerCase(cp) != lowerJ.reset(str).matches()|| 3804 // upper 3805 POSIX_ASCII.isUpper(cp) != upper.reset(str).matches() || 3806 POSIX_Unicode.isUpper(cp) != upperU.reset(str).matches() || 3807 Character.isUpperCase(cp) != upperP.reset(str).matches() || 3808 Character.isUpperCase(cp) != upperJ.reset(str).matches() || 3809 // alpha 3810 POSIX_ASCII.isAlpha(cp) != alpha.reset(str).matches() || 3811 POSIX_Unicode.isAlpha(cp) != alphaU.reset(str).matches() || 3812 Character.isAlphabetic(cp)!= alphaP.reset(str).matches() || 3813 Character.isAlphabetic(cp)!= alphaJ.reset(str).matches() || 3814 // digit 3815 POSIX_ASCII.isDigit(cp) != digit.reset(str).matches() || 3816 Character.isDigit(cp) != digitU.reset(str).matches() || 3817 // alnum 3818 POSIX_ASCII.isAlnum(cp) != alnum.reset(str).matches() || 3819 POSIX_Unicode.isAlnum(cp) != alnumU.reset(str).matches() || 3820 // punct 3821 POSIX_ASCII.isPunct(cp) != punct.reset(str).matches() || 3822 POSIX_Unicode.isPunct(cp) != punctU.reset(str).matches() || 3823 // graph 3824 POSIX_ASCII.isGraph(cp) != graph.reset(str).matches() || 3825 POSIX_Unicode.isGraph(cp) != graphU.reset(str).matches() || 3826 POSIX_Unicode.isGraph(cp) != graphEU.reset(str).matches()|| 3827 // blank 3828 POSIX_ASCII.isType(cp, POSIX_ASCII.BLANK) 3829 != blank.reset(str).matches() || 3830 POSIX_Unicode.isBlank(cp) != blankU.reset(str).matches() || 3831 // print 3832 POSIX_ASCII.isPrint(cp) != print.reset(str).matches() || 3833 POSIX_Unicode.isPrint(cp) != printU.reset(str).matches() || 3834 // cntrl 3835 POSIX_ASCII.isCntrl(cp) != cntrl.reset(str).matches() || 3836 POSIX_Unicode.isCntrl(cp) != cntrlU.reset(str).matches() || 3837 (Character.CONTROL == type) != cntrlP.reset(str).matches() || 3838 // hexdigit 3839 POSIX_ASCII.isHexDigit(cp) != xdigit.reset(str).matches() || 3840 POSIX_Unicode.isHexDigit(cp) != xdigitU.reset(str).matches() || 3841 // space 3842 POSIX_ASCII.isSpace(cp) != space.reset(str).matches() || 3843 POSIX_Unicode.isSpace(cp) != spaceU.reset(str).matches() || 3844 POSIX_Unicode.isSpace(cp) != spaceP.reset(str).matches() || 3845 // word 3846 POSIX_ASCII.isWord(cp) != word.reset(str).matches() || 3847 POSIX_Unicode.isWord(cp) != wordU.reset(str).matches() || 3848 POSIX_Unicode.isWord(cp) != wordEU.reset(str).matches()|| 3849 // bwordb 3850 POSIX_ASCII.isWord(cp) != bwb.reset(str).matches() || 3851 POSIX_Unicode.isWord(cp) != bwbU.reset(str).matches() || 3852 // properties 3853 Character.isTitleCase(cp) != titleP.reset(str).matches() || 3854 Character.isLetter(cp) != letterP.reset(str).matches()|| 3855 Character.isIdeographic(cp) != ideogP.reset(str).matches() || 3856 Character.isIdeographic(cp) != ideogJ.reset(str).matches() || 3857 (Character.UNASSIGNED == type) == definedP.reset(str).matches() || 3858 POSIX_Unicode.isNoncharacterCodePoint(cp) != nonCCPP.reset(str).matches() || 3859 POSIX_Unicode.isJoinControl(cp) != joinCrtl.reset(str).matches()) 3860 failCount++; 3861 } 3862 3863 // bounds/word align 3864 twoFindIndexes(" \u0180sherman\u0400 ", bound, 1, 10); 3865 if (!bwbU.reset("\u0180sherman\u0400").matches()) 3866 failCount++; 3867 twoFindIndexes(" \u0180sh\u0345erman\u0400 ", bound, 1, 11); 3868 if (!bwbU.reset("\u0180sh\u0345erman\u0400").matches()) 3869 failCount++; 3870 twoFindIndexes(" \u0724\u0739\u0724 ", bound, 1, 4); 3871 if (!bwbU.reset("\u0724\u0739\u0724").matches()) 3872 failCount++; 3873 if (!bwbEU.reset("\u0724\u0739\u0724").matches()) 3874 failCount++; 3875 report("unicodePredefinedClasses"); 3876 } 3877 3878 private static void horizontalAndVerticalWSTest() throws Exception { 3879 String hws = new String (new char[] { 3880 0x09, 0x20, 0xa0, 0x1680, 0x180e, 3881 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 3882 0x2006, 0x2007, 0x2008, 0x2009, 0x200a, 3883 0x202f, 0x205f, 0x3000 }); 3884 String vws = new String (new char[] { 3885 0x0a, 0x0b, 0x0c, 0x0d, 0x85, 0x2028, 0x2029 }); 3886 if (!Pattern.compile("\\h+").matcher(hws).matches() || 3887 !Pattern.compile("[\\h]+").matcher(hws).matches()) 3888 failCount++; 3889 if (Pattern.compile("\\H").matcher(hws).find() || 3890 Pattern.compile("[\\H]").matcher(hws).find()) 3891 failCount++; 3892 if (!Pattern.compile("\\v+").matcher(vws).matches() || 3893 !Pattern.compile("[\\v]+").matcher(vws).matches()) 3894 failCount++; 3895 if (Pattern.compile("\\V").matcher(vws).find() || 3896 Pattern.compile("[\\V]").matcher(vws).find()) 3897 failCount++; 3898 String prefix = "abcd"; 3899 String suffix = "efgh"; 3900 String ng = "A"; 3901 for (int i = 0; i < hws.length(); i++) { 3902 String c = String.valueOf(hws.charAt(i)); 3903 Matcher m = Pattern.compile("\\h").matcher(prefix + c + suffix); 3904 if (!m.find() || !c.equals(m.group())) 3905 failCount++; 3906 m = Pattern.compile("[\\h]").matcher(prefix + c + suffix); 3907 if (!m.find() || !c.equals(m.group())) 3908 failCount++; 3909 3910 m = Pattern.compile("\\H").matcher(hws.substring(0, i) + ng + hws.substring(i)); 3911 if (!m.find() || !ng.equals(m.group())) 3912 failCount++; 3913 m = Pattern.compile("[\\H]").matcher(hws.substring(0, i) + ng + hws.substring(i)); 3914 if (!m.find() || !ng.equals(m.group())) 3915 failCount++; 3916 } 3917 for (int i = 0; i < vws.length(); i++) { 3918 String c = String.valueOf(vws.charAt(i)); 3919 Matcher m = Pattern.compile("\\v").matcher(prefix + c + suffix); 3920 if (!m.find() || !c.equals(m.group())) 3921 failCount++; 3922 m = Pattern.compile("[\\v]").matcher(prefix + c + suffix); 3923 if (!m.find() || !c.equals(m.group())) 3924 failCount++; 3925 3926 m = Pattern.compile("\\V").matcher(vws.substring(0, i) + ng + vws.substring(i)); 3927 if (!m.find() || !ng.equals(m.group())) 3928 failCount++; 3929 m = Pattern.compile("[\\V]").matcher(vws.substring(0, i) + ng + vws.substring(i)); 3930 if (!m.find() || !ng.equals(m.group())) 3931 failCount++; 3932 } 3933 // \v in range is interpreted as 0x0B. This is the undocumented behavior 3934 if (!Pattern.compile("[\\v-\\v]").matcher(String.valueOf((char)0x0B)).matches()) 3935 failCount++; 3936 report("horizontalAndVerticalWSTest"); 3937 } 3938 3939 private static void linebreakTest() throws Exception { 3940 String linebreaks = new String (new char[] { 3941 0x0A, 0x0B, 0x0C, 0x0D, 0x85, 0x2028, 0x2029 }); 3942 String crnl = "\r\n"; 3943 if (!Pattern.compile("\\R+").matcher(linebreaks).matches() || 3944 !Pattern.compile("\\R").matcher(crnl).matches() || 3945 Pattern.compile("\\R\\R").matcher(crnl).matches()) 3946 failCount++; 3947 report("linebreakTest"); 3948 } 3949 3950 // #7189363 3951 private static void branchTest() throws Exception { 3952 if (!Pattern.compile("(a)?bc|d").matcher("d").find() || // greedy 3953 !Pattern.compile("(a)+bc|d").matcher("d").find() || 3954 !Pattern.compile("(a)*bc|d").matcher("d").find() || 3955 !Pattern.compile("(a)??bc|d").matcher("d").find() || // reluctant 3956 !Pattern.compile("(a)+?bc|d").matcher("d").find() || 3957 !Pattern.compile("(a)*?bc|d").matcher("d").find() || 3958 !Pattern.compile("(a)?+bc|d").matcher("d").find() || // possessive 3959 !Pattern.compile("(a)++bc|d").matcher("d").find() || 3960 !Pattern.compile("(a)*+bc|d").matcher("d").find() || 3961 !Pattern.compile("(a)?bc|d").matcher("d").matches() || // greedy 3962 !Pattern.compile("(a)+bc|d").matcher("d").matches() || 3963 !Pattern.compile("(a)*bc|d").matcher("d").matches() || 3964 !Pattern.compile("(a)??bc|d").matcher("d").matches() || // reluctant 3965 !Pattern.compile("(a)+?bc|d").matcher("d").matches() || 3966 !Pattern.compile("(a)*?bc|d").matcher("d").matches() || 3967 !Pattern.compile("(a)?+bc|d").matcher("d").matches() || // possessive 3968 !Pattern.compile("(a)++bc|d").matcher("d").matches() || 3969 !Pattern.compile("(a)*+bc|d").matcher("d").matches() || 3970 !Pattern.compile("(a)?bc|de").matcher("de").find() || // others 3971 !Pattern.compile("(a)??bc|de").matcher("de").find() || 3972 !Pattern.compile("(a)?bc|de").matcher("de").matches() || 3973 !Pattern.compile("(a)??bc|de").matcher("de").matches()) 3974 failCount++; 3975 report("branchTest"); 3976 } 3977 3978 // This test is for 8007395 3979 private static void groupCurlyNotFoundSuppTest() throws Exception { 3980 String input = "test this as \ud83d\ude0d"; 3981 for (String pStr : new String[] { "test(.)+(@[a-zA-Z.]+)", 3982 "test(.)*(@[a-zA-Z.]+)", 3983 "test([^B])+(@[a-zA-Z.]+)", 3984 "test([^B])*(@[a-zA-Z.]+)", 3985 "test(\\P{IsControl})+(@[a-zA-Z.]+)", 3986 "test(\\P{IsControl})*(@[a-zA-Z.]+)", 3987 }) { 3988 Matcher m = Pattern.compile(pStr, Pattern.CASE_INSENSITIVE) 3989 .matcher(input); 3990 try { 3991 if (m.find()) { 3992 failCount++; 3993 } 3994 } catch (Exception x) { 3995 failCount++; 3996 } 3997 } 3998 report("GroupCurly NotFoundSupp"); 3999 } 4000 4001 // This test is for 8023647 4002 private static void groupCurlyBackoffTest() throws Exception { 4003 if (!"abc1c".matches("(\\w)+1\\1") || 4004 "abc11".matches("(\\w)+1\\1")) { 4005 failCount++; 4006 } 4007 report("GroupCurly backoff"); 4008 } 4009 4010 // This test is for 8012646 4011 private static void patternAsPredicate() throws Exception { 4012 Predicate<String> p = Pattern.compile("[a-z]+").asPredicate(); 4013 4014 if (p.test("")) { 4015 failCount++; 4016 } 4017 if (!p.test("word")) { 4018 failCount++; 4019 } 4020 if (p.test("1234")) { 4021 failCount++; 4022 } 4023 report("Pattern.asPredicate"); 4024 } 4025} 4026