author | chegar |
Thu, 17 Oct 2019 20:54:25 +0100 | |
branch | datagramsocketimpl-branch |
changeset 58679 | 9c3209ff7550 |
parent 58678 | 9cf78a70fa4f |
parent 58111 | f63f50a4bf43 |
permissions | -rw-r--r-- |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1 |
/* |
55096
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
2 |
* Copyright (c) 1999, 2019, Oracle and/or its affiliates. All rights reserved. |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3 |
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4 |
* |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
5 |
* This code is free software; you can redistribute it and/or modify it |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
6 |
* under the terms of the GNU General Public License version 2 only, as |
21596 | 7 |
* published by the Free Software Foundation. |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
8 |
* |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
9 |
* This code is distributed in the hope that it will be useful, but WITHOUT |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
10 |
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
11 |
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
12 |
* version 2 for more details (a copy is included in the LICENSE file that |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
13 |
* accompanied this code). |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
14 |
* |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
15 |
* You should have received a copy of the GNU General Public License version |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
16 |
* 2 along with this work; if not, write to the Free Software Foundation, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
17 |
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
18 |
* |
5506 | 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. |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
22 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
23 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
24 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
25 |
* @test |
30370
984bf40cdc67
8079419: Update to RegEx test to use random number library
darcy
parents:
30046
diff
changeset
|
26 |
* @summary tests RegExp framework (use -Dseed=X to set PRNG seed) |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
27 |
* @author Mike McCloskey |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
28 |
* @bug 4481568 4482696 4495089 4504687 4527731 4599621 4631553 4619345 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
29 |
* 4630911 4672616 4711773 4727935 4750573 4792284 4803197 4757029 4808962 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
30 |
* 4872664 4803179 4892980 4900747 4945394 4938995 4979006 4994840 4997476 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
31 |
* 5013885 5003322 4988891 5098443 5110268 6173522 4829857 5027748 6376940 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
32 |
* 6358731 6178785 6284152 6231989 6497148 6486934 6233084 6504326 6635133 |
11287
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
33 |
* 6350801 6676425 6878475 6919132 6931676 6948903 6990617 7014645 7039066 |
21668 | 34 |
* 7067045 7014640 7189363 8007395 8013252 8013254 8012646 8023647 6559590 |
35783
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
35 |
* 8027645 8035076 8039124 8035975 8074678 6854417 8143854 8147531 7071819 |
45888
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
36 |
* 8151481 4867170 7080302 6728861 6995635 6736245 4916384 6328855 6192895 |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
37 |
* 6345469 6988218 6693451 7006761 8140212 8143282 8158482 8176029 8184706 |
58111
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
38 |
* 8194667 8197462 8184692 8221431 8224789 8228352 8230829 |
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
39 |
* |
45288
58be10a068c2
8180805: move RandomFactory to the top level testlibrary
iignatyev
parents:
44122
diff
changeset
|
40 |
* @library /test/lib |
55013 | 41 |
* @library /lib/testlibrary/java/lang |
45466
faf1c55d2046
8181759: add explicit @build actions for jdk.test.lib classes in all :tier1 tests
iignatyev
parents:
45288
diff
changeset
|
42 |
* @build jdk.test.lib.RandomFactory |
30370
984bf40cdc67
8079419: Update to RegEx test to use random number library
darcy
parents:
30046
diff
changeset
|
43 |
* @run main RegExTest |
31645
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
44 |
* @key randomness |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
45 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
46 |
|
55096
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
47 |
import java.io.BufferedReader; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
48 |
import java.io.ByteArrayInputStream; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
49 |
import java.io.ByteArrayOutputStream; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
50 |
import java.io.File; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
51 |
import java.io.FileInputStream; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
52 |
import java.io.InputStreamReader; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
53 |
import java.io.ObjectInputStream; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
54 |
import java.io.ObjectOutputStream; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
55 |
import java.math.BigInteger; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
56 |
import java.nio.CharBuffer; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
57 |
import java.nio.file.Files; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
58 |
import java.util.ArrayList; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
59 |
import java.util.Arrays; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
60 |
import java.util.List; |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
61 |
import java.util.Random; |
35783
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
62 |
import java.util.Scanner; |
55096
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
63 |
import java.util.function.Function; |
17447 | 64 |
import java.util.function.Predicate; |
55096
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
65 |
import java.util.regex.Matcher; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
66 |
import java.util.regex.MatchResult; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
67 |
import java.util.regex.Pattern; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
68 |
import java.util.regex.PatternSyntaxException; |
45288
58be10a068c2
8180805: move RandomFactory to the top level testlibrary
iignatyev
parents:
44122
diff
changeset
|
69 |
import jdk.test.lib.RandomFactory; |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
70 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
71 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
72 |
* This is a test class created to check the operation of |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
73 |
* the Pattern and Matcher classes. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
74 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
75 |
public class RegExTest { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
76 |
|
30370
984bf40cdc67
8079419: Update to RegEx test to use random number library
darcy
parents:
30046
diff
changeset
|
77 |
private static Random generator = RandomFactory.getRandom(); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
78 |
private static boolean failure = false; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
79 |
private static int failCount = 0; |
11287
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
80 |
private static String firstFailure = null; |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
81 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
82 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
83 |
* Main to interpret arguments and run several tests. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
84 |
* |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
85 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
86 |
public static void main(String[] args) throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
87 |
// Most of the tests are in a file |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
88 |
processFile("TestCases.txt"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
89 |
//processFile("PerlCases.txt"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
90 |
processFile("BMPTestCases.txt"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
91 |
processFile("SupplementaryTestCases.txt"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
92 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
93 |
// These test many randomly generated char patterns |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
94 |
bm(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
95 |
slice(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
96 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
97 |
// These are hard to put into the file |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
98 |
escapes(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
99 |
blankInput(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
100 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
101 |
// Substitition tests on randomly generated sequences |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
102 |
globalSubstitute(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
103 |
stringbufferSubstitute(); |
23734
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
104 |
stringbuilderSubstitute(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
105 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
106 |
substitutionBasher(); |
23734
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
107 |
substitutionBasher2(); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
108 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
109 |
// Canonical Equivalence |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
110 |
ceTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
111 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
112 |
// Anchors |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
113 |
anchorTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
114 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
115 |
// boolean match calls |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
116 |
matchesTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
117 |
lookingAtTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
118 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
119 |
// Pattern API |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
120 |
patternMatchesTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
121 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
122 |
// Misc |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
123 |
lookbehindTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
124 |
nullArgumentTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
125 |
backRefTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
126 |
groupCaptureTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
127 |
caretTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
128 |
charClassTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
129 |
emptyPatternTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
130 |
findIntTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
131 |
group0Test(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
132 |
longPatternTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
133 |
octalTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
134 |
ampersandTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
135 |
negationTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
136 |
splitTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
137 |
appendTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
138 |
caseFoldingTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
139 |
commentsTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
140 |
unixLinesTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
141 |
replaceFirstTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
142 |
gTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
143 |
zTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
144 |
serializeTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
145 |
reluctantRepetitionTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
146 |
multilineDollarTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
147 |
dollarAtEndTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
148 |
caretBetweenTerminatorsTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
149 |
// This RFE rejected in Tiger numOccurrencesTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
150 |
javaCharClassTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
151 |
nonCaptureRepetitionTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
152 |
notCapturedGroupCurlyMatchTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
153 |
escapedSegmentTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
154 |
literalPatternTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
155 |
literalReplacementTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
156 |
regionTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
157 |
toStringTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
158 |
negatedCharClassTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
159 |
findFromTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
160 |
boundsTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
161 |
unicodeWordBoundsTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
162 |
caretAtEndTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
163 |
wordSearchTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
164 |
hitEndTest(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
165 |
toMatchResultTest(); |
29503
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
166 |
toMatchResultTest2(); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
167 |
surrogatesInClassTest(); |
11287
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
168 |
removeQEQuotingTest(); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
169 |
namedGroupCaptureTest(); |
4820
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
170 |
nonBmpClassComplementTest(); |
5610
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
171 |
unicodePropertiesTest(); |
8173
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
172 |
unicodeHexNotationTest(); |
9536
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
173 |
unicodeClassesTest(); |
35783
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
174 |
unicodeCharacterNameTest(); |
12675
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
175 |
horizontalAndVerticalWSTest(); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
176 |
linebreakTest(); |
13554
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
177 |
branchTest(); |
17183
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
178 |
groupCurlyNotFoundSuppTest(); |
19604
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
179 |
groupCurlyBackoffTest(); |
17447 | 180 |
patternAsPredicate(); |
49763 | 181 |
patternAsMatchPredicate(); |
25523
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
182 |
invalidFlags(); |
38777
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
183 |
embeddedFlags(); |
35783
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
184 |
grapheme(); |
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
185 |
expoBacktracking(); |
48853
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
186 |
invalidGroupName(); |
55096
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
187 |
illegalRepetitionRange(); |
57624
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
188 |
surrogatePairWithCanonEq(); |
21668 | 189 |
|
11287
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
190 |
if (failure) { |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
191 |
throw new |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
192 |
RuntimeException("RegExTest failed, 1st failure: " + |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
193 |
firstFailure); |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
194 |
} else { |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
195 |
System.err.println("OKAY: All tests passed."); |
11287
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
196 |
} |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
197 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
198 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
199 |
// Utility functions |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
200 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
201 |
private static String getRandomAlphaString(int length) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
202 |
StringBuffer buf = new StringBuffer(length); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
203 |
for (int i=0; i<length; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
204 |
char randChar = (char)(97 + generator.nextInt(26)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
205 |
buf.append(randChar); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
206 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
207 |
return buf.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
208 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
209 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
210 |
private static void check(Matcher m, String expected) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
211 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
212 |
if (!m.group().equals(expected)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
213 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
214 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
215 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
216 |
private static void check(Matcher m, String result, boolean expected) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
217 |
m.find(); |
8173
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
218 |
if (m.group().equals(result) != expected) |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
219 |
failCount++; |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
220 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
221 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
222 |
private static void check(Pattern p, String s, boolean expected) { |
8173
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
223 |
if (p.matcher(s).find() != expected) |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
224 |
failCount++; |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
225 |
} |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
226 |
|
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
227 |
private static void check(String p, String s, boolean expected) { |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
228 |
Matcher matcher = Pattern.compile(p).matcher(s); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
229 |
if (matcher.find() != expected) |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
230 |
failCount++; |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
231 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
232 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
233 |
private static void check(String p, char c, boolean expected) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
234 |
String propertyPattern = expected ? "\\p" + p : "\\P" + p; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
235 |
Pattern pattern = Pattern.compile(propertyPattern); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
236 |
char[] ca = new char[1]; ca[0] = c; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
237 |
Matcher matcher = pattern.matcher(new String(ca)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
238 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
239 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
240 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
241 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
242 |
private static void check(String p, int codePoint, boolean expected) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
243 |
String propertyPattern = expected ? "\\p" + p : "\\P" + p; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
244 |
Pattern pattern = Pattern.compile(propertyPattern); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
245 |
char[] ca = Character.toChars(codePoint); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
246 |
Matcher matcher = pattern.matcher(new String(ca)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
247 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
248 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
249 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
250 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
251 |
private static void check(String p, int flag, String input, String s, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
252 |
boolean expected) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
253 |
{ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
254 |
Pattern pattern = Pattern.compile(p, flag); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
255 |
Matcher matcher = pattern.matcher(input); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
256 |
if (expected) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
257 |
check(matcher, s, expected); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
258 |
else |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
259 |
check(pattern, input, false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
260 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
261 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
262 |
private static void report(String testName) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
263 |
int spacesToAdd = 30 - testName.length(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
264 |
StringBuffer paddedNameBuffer = new StringBuffer(testName); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
265 |
for (int i=0; i<spacesToAdd; i++) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
266 |
paddedNameBuffer.append(" "); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
267 |
String paddedName = paddedNameBuffer.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
268 |
System.err.println(paddedName + ": " + |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
269 |
(failCount==0 ? "Passed":"Failed("+failCount+")")); |
11287
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
270 |
if (failCount > 0) { |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
271 |
failure = true; |
11287
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
272 |
|
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
273 |
if (firstFailure == null) { |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
274 |
firstFailure = testName; |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
275 |
} |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
276 |
} |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
277 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
278 |
failCount = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
279 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
280 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
281 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
282 |
* Converts ASCII alphabet characters [A-Za-z] in the given 's' to |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
283 |
* supplementary characters. This method does NOT fully take care |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
284 |
* of the regex syntax. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
285 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
286 |
private static String toSupplementaries(String s) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
287 |
int length = s.length(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
288 |
StringBuffer sb = new StringBuffer(length * 2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
289 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
290 |
for (int i = 0; i < length; ) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
291 |
char c = s.charAt(i++); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
292 |
if (c == '\\') { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
293 |
sb.append(c); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
294 |
if (i < length) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
295 |
c = s.charAt(i++); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
296 |
sb.append(c); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
297 |
if (c == 'u') { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
298 |
// assume no syntax error |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
299 |
sb.append(s.charAt(i++)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
300 |
sb.append(s.charAt(i++)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
301 |
sb.append(s.charAt(i++)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
302 |
sb.append(s.charAt(i++)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
303 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
304 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
305 |
} else if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
306 |
sb.append('\ud800').append((char)('\udc00'+c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
307 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
308 |
sb.append(c); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
309 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
310 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
311 |
return sb.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
312 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
313 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
314 |
// Regular expression tests |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
315 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
316 |
// This is for bug 6178785 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
317 |
// Test if an expected NPE gets thrown when passing in a null argument |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
318 |
private static boolean check(Runnable test) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
319 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
320 |
test.run(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
321 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
322 |
return false; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
323 |
} catch (NullPointerException npe) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
324 |
return true; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
325 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
326 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
327 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
328 |
private static void nullArgumentTest() { |
29243
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
329 |
check(() -> Pattern.compile(null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
330 |
check(() -> Pattern.matches(null, null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
331 |
check(() -> Pattern.matches("xyz", null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
332 |
check(() -> Pattern.quote(null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
333 |
check(() -> Pattern.compile("xyz").split(null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
334 |
check(() -> Pattern.compile("xyz").matcher(null)); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
335 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
336 |
final Matcher m = Pattern.compile("xyz").matcher("xyz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
337 |
m.matches(); |
29243
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
338 |
check(() -> m.appendTail((StringBuffer) null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
339 |
check(() -> m.appendTail((StringBuilder)null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
340 |
check(() -> m.replaceAll((String) null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
341 |
check(() -> m.replaceAll((Function<MatchResult, String>)null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
342 |
check(() -> m.replaceFirst((String)null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
343 |
check(() -> m.replaceFirst((Function<MatchResult, String>) null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
344 |
check(() -> m.appendReplacement((StringBuffer)null, null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
345 |
check(() -> m.appendReplacement((StringBuilder)null, null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
346 |
check(() -> m.reset(null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
347 |
check(() -> Matcher.quoteReplacement(null)); |
80ea8d3d39d0
8071479: Stream and lambdafication improvements to j.u.regex.Matcher
psandoz
parents:
25523
diff
changeset
|
348 |
//check(() -> m.usePattern(null)); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
349 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
350 |
report("Null Argument"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
351 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
352 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
353 |
// This is for bug6635133 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
354 |
// Test if surrogate pair in Unicode escapes can be handled correctly. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
355 |
private static void surrogatesInClassTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
356 |
Pattern pattern = Pattern.compile("[\\ud834\\udd21-\\ud834\\udd24]"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
357 |
Matcher matcher = pattern.matcher("\ud834\udd22"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
358 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
359 |
failCount++; |
11287
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
360 |
|
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
361 |
report("Surrogate pair in Unicode escape"); |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
362 |
} |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
363 |
|
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
364 |
// This is for bug6990617 |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
365 |
// Test if Pattern.RemoveQEQuoting works correctly if the octal unicode |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
366 |
// char encoding is only 2 or 3 digits instead of 4 and the first quoted |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
367 |
// char is an octal digit. |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
368 |
private static void removeQEQuotingTest() throws Exception { |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
369 |
Pattern pattern = |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
370 |
Pattern.compile("\\011\\Q1sometext\\E\\011\\Q2sometext\\E"); |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
371 |
Matcher matcher = pattern.matcher("\t1sometext\t2sometext"); |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
372 |
if (!matcher.find()) |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
373 |
failCount++; |
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
374 |
|
3db172a5433c
6990617: Regular expression doesn't match if unicode character next to a digit.
sherman
parents:
9536
diff
changeset
|
375 |
report("Remove Q/E Quoting"); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
376 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
377 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
378 |
// This is for bug 4988891 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
379 |
// Test toMatchResult to see that it is a copy of the Matcher |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
380 |
// that is not affected by subsequent operations on the original |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
381 |
private static void toMatchResultTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
382 |
Pattern pattern = Pattern.compile("squid"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
383 |
Matcher matcher = pattern.matcher( |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
384 |
"agiantsquidofdestinyasmallsquidoffate"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
385 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
386 |
int matcherStart1 = matcher.start(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
387 |
MatchResult mr = matcher.toMatchResult(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
388 |
if (mr == matcher) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
389 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
390 |
int resultStart1 = mr.start(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
391 |
if (matcherStart1 != resultStart1) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
392 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
393 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
394 |
int matcherStart2 = matcher.start(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
395 |
int resultStart2 = mr.start(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
396 |
if (matcherStart2 == resultStart2) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
397 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
398 |
if (resultStart1 != resultStart2) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
399 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
400 |
MatchResult mr2 = matcher.toMatchResult(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
401 |
if (mr == mr2) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
402 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
403 |
if (mr2.start() != matcherStart2) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
404 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
405 |
report("toMatchResult is a copy"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
406 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
407 |
|
29503
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
408 |
private static void checkExpectedISE(Runnable test) { |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
409 |
try { |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
410 |
test.run(); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
411 |
failCount++; |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
412 |
} catch (IllegalStateException x) { |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
413 |
} catch (IndexOutOfBoundsException xx) { |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
414 |
failCount++; |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
415 |
} |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
416 |
} |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
417 |
|
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
418 |
private static void checkExpectedIOOE(Runnable test) { |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
419 |
try { |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
420 |
test.run(); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
421 |
failCount++; |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
422 |
} catch (IndexOutOfBoundsException x) {} |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
423 |
} |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
424 |
|
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
425 |
// This is for bug 8074678 |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
426 |
// Test the result of toMatchResult throws ISE if no match is availble |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
427 |
private static void toMatchResultTest2() throws Exception { |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
428 |
Matcher matcher = Pattern.compile("nomatch").matcher("hello world"); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
429 |
matcher.find(); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
430 |
MatchResult mr = matcher.toMatchResult(); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
431 |
|
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
432 |
checkExpectedISE(() -> mr.start()); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
433 |
checkExpectedISE(() -> mr.start(2)); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
434 |
checkExpectedISE(() -> mr.end()); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
435 |
checkExpectedISE(() -> mr.end(2)); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
436 |
checkExpectedISE(() -> mr.group()); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
437 |
checkExpectedISE(() -> mr.group(2)); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
438 |
|
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
439 |
matcher = Pattern.compile("(match)").matcher("there is a match"); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
440 |
matcher.find(); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
441 |
MatchResult mr2 = matcher.toMatchResult(); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
442 |
checkExpectedIOOE(() -> mr2.start(2)); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
443 |
checkExpectedIOOE(() -> mr2.end(2)); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
444 |
checkExpectedIOOE(() -> mr2.group(2)); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
445 |
|
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
446 |
report("toMatchResult2 appropriate exceptions"); |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
447 |
} |
95318f222149
8074678: JCK test java_util/regex/MatchResult/index.html starts failing after JDK-8071479
sherman
parents:
29243
diff
changeset
|
448 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
449 |
// This is for bug 5013885 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
450 |
// Must test a slice to see if it reports hitEnd correctly |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
451 |
private static void hitEndTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
452 |
// Basic test of Slice node |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
453 |
Pattern p = Pattern.compile("^squidattack"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
454 |
Matcher m = p.matcher("squack"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
455 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
456 |
if (m.hitEnd()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
457 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
458 |
m.reset("squid"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
459 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
460 |
if (!m.hitEnd()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
461 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
462 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
463 |
// Test Slice, SliceA and SliceU nodes |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
464 |
for (int i=0; i<3; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
465 |
int flags = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
466 |
if (i==1) flags = Pattern.CASE_INSENSITIVE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
467 |
if (i==2) flags = Pattern.UNICODE_CASE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
468 |
p = Pattern.compile("^abc", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
469 |
m = p.matcher("ad"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
470 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
471 |
if (m.hitEnd()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
472 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
473 |
m.reset("ab"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
474 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
475 |
if (!m.hitEnd()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
476 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
477 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
478 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
479 |
// Test Boyer-Moore node |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
480 |
p = Pattern.compile("catattack"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
481 |
m = p.matcher("attack"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
482 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
483 |
if (!m.hitEnd()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
484 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
485 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
486 |
p = Pattern.compile("catattack"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
487 |
m = p.matcher("attackattackattackcatatta"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
488 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
489 |
if (!m.hitEnd()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
490 |
failCount++; |
45888
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
491 |
|
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
492 |
// 8184706: Matching u+0d at EOL against \R should hit-end |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
493 |
p = Pattern.compile("...\\R"); |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
494 |
m = p.matcher("cat" + (char)0x0a); |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
495 |
m.find(); |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
496 |
if (m.hitEnd()) |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
497 |
failCount++; |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
498 |
|
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
499 |
m = p.matcher("cat" + (char)0x0d); |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
500 |
m.find(); |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
501 |
if (!m.hitEnd()) |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
502 |
failCount++; |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
503 |
|
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
504 |
m = p.matcher("cat" + (char)0x0d + (char)0x0a); |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
505 |
m.find(); |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
506 |
if (m.hitEnd()) |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
507 |
failCount++; |
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
508 |
|
ae448cf92e00
8184706: Matcher doesn't indicate hitEnd after matching \u0D with \R at EOL
igerasim
parents:
45466
diff
changeset
|
509 |
report("hitEnd"); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
510 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
511 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
512 |
// This is for bug 4997476 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
513 |
// It is weird code submitted by customer demonstrating a regression |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
514 |
private static void wordSearchTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
515 |
String testString = new String("word1 word2 word3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
516 |
Pattern p = Pattern.compile("\\b"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
517 |
Matcher m = p.matcher(testString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
518 |
int position = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
519 |
int start = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
520 |
while (m.find(position)) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
521 |
start = m.start(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
522 |
if (start == testString.length()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
523 |
break; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
524 |
if (m.find(start+1)) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
525 |
position = m.start(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
526 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
527 |
position = testString.length(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
528 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
529 |
if (testString.substring(start, position).equals(" ")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
530 |
continue; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
531 |
if (!testString.substring(start, position-1).startsWith("word")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
532 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
533 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
534 |
report("Customer word search"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
535 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
536 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
537 |
// This is for bug 4994840 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
538 |
private static void caretAtEndTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
539 |
// Problem only occurs with multiline patterns |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
540 |
// containing a beginning-of-line caret "^" followed |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
541 |
// by an expression that also matches the empty string. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
542 |
Pattern pattern = Pattern.compile("^x?", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
543 |
Matcher matcher = pattern.matcher("\r"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
544 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
545 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
546 |
report("Caret at end"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
547 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
548 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
549 |
// This test is for 4979006 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
550 |
// Check to see if word boundary construct properly handles unicode |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
551 |
// non spacing marks |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
552 |
private static void unicodeWordBoundsTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
553 |
String spaces = " "; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
554 |
String wordChar = "a"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
555 |
String nsm = "\u030a"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
556 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
557 |
assert (Character.getType('\u030a') == Character.NON_SPACING_MARK); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
558 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
559 |
Pattern pattern = Pattern.compile("\\b"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
560 |
Matcher matcher = pattern.matcher(""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
561 |
// S=other B=word character N=non spacing mark .=word boundary |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
562 |
// SS.BB.SS |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
563 |
String input = spaces + wordChar + wordChar + spaces; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
564 |
twoFindIndexes(input, matcher, 2, 4); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
565 |
// SS.BBN.SS |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
566 |
input = spaces + wordChar +wordChar + nsm + spaces; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
567 |
twoFindIndexes(input, matcher, 2, 5); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
568 |
// SS.BN.SS |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
569 |
input = spaces + wordChar + nsm + spaces; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
570 |
twoFindIndexes(input, matcher, 2, 4); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
571 |
// SS.BNN.SS |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
572 |
input = spaces + wordChar + nsm + nsm + spaces; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
573 |
twoFindIndexes(input, matcher, 2, 5); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
574 |
// SSN.BB.SS |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
575 |
input = spaces + nsm + wordChar + wordChar + spaces; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
576 |
twoFindIndexes(input, matcher, 3, 5); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
577 |
// SS.BNB.SS |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
578 |
input = spaces + wordChar + nsm + wordChar + spaces; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
579 |
twoFindIndexes(input, matcher, 2, 5); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
580 |
// SSNNSS |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
581 |
input = spaces + nsm + nsm + spaces; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
582 |
matcher.reset(input); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
583 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
584 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
585 |
// SSN.BBN.SS |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
586 |
input = spaces + nsm + wordChar + wordChar + nsm + spaces; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
587 |
twoFindIndexes(input, matcher, 3, 6); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
588 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
589 |
report("Unicode word boundary"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
590 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
591 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
592 |
private static void twoFindIndexes(String input, Matcher matcher, int a, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
593 |
int b) throws Exception |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
594 |
{ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
595 |
matcher.reset(input); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
596 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
597 |
if (matcher.start() != a) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
598 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
599 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
600 |
if (matcher.start() != b) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
601 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
602 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
603 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
604 |
// This test is for 6284152 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
605 |
static void check(String regex, String input, String[] expected) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
606 |
List<String> result = new ArrayList<String>(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
607 |
Pattern p = Pattern.compile(regex); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
608 |
Matcher m = p.matcher(input); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
609 |
while (m.find()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
610 |
result.add(m.group()); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
611 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
612 |
if (!Arrays.asList(expected).equals(result)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
613 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
614 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
615 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
616 |
private static void lookbehindTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
617 |
//Positive |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
618 |
check("(?<=%.{0,5})foo\\d", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
619 |
"%foo1\n%bar foo2\n%bar foo3\n%blahblah foo4\nfoo5", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
620 |
new String[]{"foo1", "foo2", "foo3"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
621 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
622 |
//boundary at end of the lookbehind sub-regex should work consistently |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
623 |
//with the boundary just after the lookbehind sub-regex |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
624 |
check("(?<=.*\\b)foo", "abcd foo", new String[]{"foo"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
625 |
check("(?<=.*)\\bfoo", "abcd foo", new String[]{"foo"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
626 |
check("(?<!abc )\\bfoo", "abc foo", new String[0]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
627 |
check("(?<!abc \\b)foo", "abc foo", new String[0]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
628 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
629 |
//Negative |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
630 |
check("(?<!%.{0,5})foo\\d", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
631 |
"%foo1\n%bar foo2\n%bar foo3\n%blahblah foo4\nfoo5", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
632 |
new String[] {"foo4", "foo5"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
633 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
634 |
//Positive greedy |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
635 |
check("(?<=%b{1,4})foo", "%bbbbfoo", new String[] {"foo"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
636 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
637 |
//Positive reluctant |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
638 |
check("(?<=%b{1,4}?)foo", "%bbbbfoo", new String[] {"foo"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
639 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
640 |
//supplementary |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
641 |
check("(?<=%b{1,4})fo\ud800\udc00o", "%bbbbfo\ud800\udc00o", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
642 |
new String[] {"fo\ud800\udc00o"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
643 |
check("(?<=%b{1,4}?)fo\ud800\udc00o", "%bbbbfo\ud800\udc00o", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
644 |
new String[] {"fo\ud800\udc00o"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
645 |
check("(?<!%b{1,4})fo\ud800\udc00o", "%afo\ud800\udc00o", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
646 |
new String[] {"fo\ud800\udc00o"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
647 |
check("(?<!%b{1,4}?)fo\ud800\udc00o", "%afo\ud800\udc00o", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
648 |
new String[] {"fo\ud800\udc00o"}); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
649 |
report("Lookbehind"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
650 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
651 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
652 |
// This test is for 4938995 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
653 |
// Check to see if weak region boundaries are transparent to |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
654 |
// lookahead and lookbehind constructs |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
655 |
private static void boundsTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
656 |
String fullMessage = "catdogcat"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
657 |
Pattern pattern = Pattern.compile("(?<=cat)dog(?=cat)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
658 |
Matcher matcher = pattern.matcher("catdogca"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
659 |
matcher.useTransparentBounds(true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
660 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
661 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
662 |
matcher.reset("atdogcat"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
663 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
664 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
665 |
matcher.reset(fullMessage); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
666 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
667 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
668 |
matcher.reset(fullMessage); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
669 |
matcher.region(0,9); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
670 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
671 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
672 |
matcher.reset(fullMessage); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
673 |
matcher.region(0,6); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
674 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
675 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
676 |
matcher.reset(fullMessage); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
677 |
matcher.region(3,6); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
678 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
679 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
680 |
matcher.useTransparentBounds(false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
681 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
682 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
683 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
684 |
// Negative lookahead/lookbehind |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
685 |
pattern = Pattern.compile("(?<!cat)dog(?!cat)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
686 |
matcher = pattern.matcher("dogcat"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
687 |
matcher.useTransparentBounds(true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
688 |
matcher.region(0,3); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
689 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
690 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
691 |
matcher.reset("catdog"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
692 |
matcher.region(3,6); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
693 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
694 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
695 |
matcher.useTransparentBounds(false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
696 |
matcher.reset("dogcat"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
697 |
matcher.region(0,3); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
698 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
699 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
700 |
matcher.reset("catdog"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
701 |
matcher.region(3,6); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
702 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
703 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
704 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
705 |
report("Region bounds transparency"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
706 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
707 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
708 |
// This test is for 4945394 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
709 |
private static void findFromTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
710 |
String message = "This is 40 $0 message."; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
711 |
Pattern pat = Pattern.compile("\\$0"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
712 |
Matcher match = pat.matcher(message); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
713 |
if (!match.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
714 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
715 |
if (match.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
716 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
717 |
if (match.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
718 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
719 |
report("Check for alternating find"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
720 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
721 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
722 |
// This test is for 4872664 and 4892980 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
723 |
private static void negatedCharClassTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
724 |
Pattern pattern = Pattern.compile("[^>]"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
725 |
Matcher matcher = pattern.matcher("\u203A"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
726 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
727 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
728 |
pattern = Pattern.compile("[^fr]"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
729 |
matcher = pattern.matcher("a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
730 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
731 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
732 |
matcher.reset("\u203A"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
733 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
734 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
735 |
String s = "for"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
736 |
String result[] = s.split("[^fr]"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
737 |
if (!result[0].equals("f")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
738 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
739 |
if (!result[1].equals("r")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
740 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
741 |
s = "f\u203Ar"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
742 |
result = s.split("[^fr]"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
743 |
if (!result[0].equals("f")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
744 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
745 |
if (!result[1].equals("r")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
746 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
747 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
748 |
// Test adding to bits, subtracting a node, then adding to bits again |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
749 |
pattern = Pattern.compile("[^f\u203Ar]"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
750 |
matcher = pattern.matcher("a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
751 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
752 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
753 |
matcher.reset("f"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
754 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
755 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
756 |
matcher.reset("\u203A"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
757 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
758 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
759 |
matcher.reset("r"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
760 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
761 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
762 |
matcher.reset("\u203B"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
763 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
764 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
765 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
766 |
// Test subtracting a node, adding to bits, subtracting again |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
767 |
pattern = Pattern.compile("[^\u203Ar\u203B]"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
768 |
matcher = pattern.matcher("a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
769 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
770 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
771 |
matcher.reset("\u203A"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
772 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
773 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
774 |
matcher.reset("r"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
775 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
776 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
777 |
matcher.reset("\u203B"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
778 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
779 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
780 |
matcher.reset("\u203C"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
781 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
782 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
783 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
784 |
report("Negated Character Class"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
785 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
786 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
787 |
// This test is for 4628291 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
788 |
private static void toStringTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
789 |
Pattern pattern = Pattern.compile("b+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
790 |
if (pattern.toString() != "b+") |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
791 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
792 |
Matcher matcher = pattern.matcher("aaabbbccc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
793 |
String matcherString = matcher.toString(); // unspecified |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
794 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
795 |
matcherString = matcher.toString(); // unspecified |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
796 |
matcher.region(0,3); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
797 |
matcherString = matcher.toString(); // unspecified |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
798 |
matcher.reset(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
799 |
matcherString = matcher.toString(); // unspecified |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
800 |
report("toString"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
801 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
802 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
803 |
// This test is for 4808962 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
804 |
private static void literalPatternTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
805 |
int flags = Pattern.LITERAL; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
806 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
807 |
Pattern pattern = Pattern.compile("abc\\t$^", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
808 |
check(pattern, "abc\\t$^", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
809 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
810 |
pattern = Pattern.compile(Pattern.quote("abc\\t$^")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
811 |
check(pattern, "abc\\t$^", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
812 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
813 |
pattern = Pattern.compile("\\Qa^$bcabc\\E", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
814 |
check(pattern, "\\Qa^$bcabc\\E", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
815 |
check(pattern, "a^$bcabc", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
816 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
817 |
pattern = Pattern.compile("\\\\Q\\\\E"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
818 |
check(pattern, "\\Q\\E", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
819 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
820 |
pattern = Pattern.compile("\\Qabc\\Eefg\\\\Q\\\\Ehij"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
821 |
check(pattern, "abcefg\\Q\\Ehij", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
822 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
823 |
pattern = Pattern.compile("\\\\\\Q\\\\E"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
824 |
check(pattern, "\\\\\\\\", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
825 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
826 |
pattern = Pattern.compile(Pattern.quote("\\Qa^$bcabc\\E")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
827 |
check(pattern, "\\Qa^$bcabc\\E", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
828 |
check(pattern, "a^$bcabc", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
829 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
830 |
pattern = Pattern.compile(Pattern.quote("\\Qabc\\Edef")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
831 |
check(pattern, "\\Qabc\\Edef", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
832 |
check(pattern, "abcdef", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
833 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
834 |
pattern = Pattern.compile(Pattern.quote("abc\\Edef")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
835 |
check(pattern, "abc\\Edef", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
836 |
check(pattern, "abcdef", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
837 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
838 |
pattern = Pattern.compile(Pattern.quote("\\E")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
839 |
check(pattern, "\\E", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
840 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
841 |
pattern = Pattern.compile("((((abc.+?:)", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
842 |
check(pattern, "((((abc.+?:)", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
843 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
844 |
flags |= Pattern.MULTILINE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
845 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
846 |
pattern = Pattern.compile("^cat$", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
847 |
check(pattern, "abc^cat$def", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
848 |
check(pattern, "cat", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
849 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
850 |
flags |= Pattern.CASE_INSENSITIVE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
851 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
852 |
pattern = Pattern.compile("abcdef", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
853 |
check(pattern, "ABCDEF", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
854 |
check(pattern, "AbCdEf", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
855 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
856 |
flags |= Pattern.DOTALL; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
857 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
858 |
pattern = Pattern.compile("a...b", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
859 |
check(pattern, "A...b", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
860 |
check(pattern, "Axxxb", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
861 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
862 |
flags |= Pattern.CANON_EQ; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
863 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
864 |
Pattern p = Pattern.compile("testa\u030a", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
865 |
check(pattern, "testa\u030a", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
866 |
check(pattern, "test\u00e5", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
867 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
868 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
869 |
flags = Pattern.LITERAL; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
870 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
871 |
pattern = Pattern.compile(toSupplementaries("abc\\t$^"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
872 |
check(pattern, toSupplementaries("abc\\t$^"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
873 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
874 |
pattern = Pattern.compile(Pattern.quote(toSupplementaries("abc\\t$^"))); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
875 |
check(pattern, toSupplementaries("abc\\t$^"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
876 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
877 |
pattern = Pattern.compile(toSupplementaries("\\Qa^$bcabc\\E"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
878 |
check(pattern, toSupplementaries("\\Qa^$bcabc\\E"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
879 |
check(pattern, toSupplementaries("a^$bcabc"), false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
880 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
881 |
pattern = Pattern.compile(Pattern.quote(toSupplementaries("\\Qa^$bcabc\\E"))); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
882 |
check(pattern, toSupplementaries("\\Qa^$bcabc\\E"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
883 |
check(pattern, toSupplementaries("a^$bcabc"), false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
884 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
885 |
pattern = Pattern.compile(Pattern.quote(toSupplementaries("\\Qabc\\Edef"))); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
886 |
check(pattern, toSupplementaries("\\Qabc\\Edef"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
887 |
check(pattern, toSupplementaries("abcdef"), false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
888 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
889 |
pattern = Pattern.compile(Pattern.quote(toSupplementaries("abc\\Edef"))); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
890 |
check(pattern, toSupplementaries("abc\\Edef"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
891 |
check(pattern, toSupplementaries("abcdef"), false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
892 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
893 |
pattern = Pattern.compile(toSupplementaries("((((abc.+?:)"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
894 |
check(pattern, toSupplementaries("((((abc.+?:)"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
895 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
896 |
flags |= Pattern.MULTILINE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
897 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
898 |
pattern = Pattern.compile(toSupplementaries("^cat$"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
899 |
check(pattern, toSupplementaries("abc^cat$def"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
900 |
check(pattern, toSupplementaries("cat"), false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
901 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
902 |
flags |= Pattern.DOTALL; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
903 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
904 |
// note: this is case-sensitive. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
905 |
pattern = Pattern.compile(toSupplementaries("a...b"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
906 |
check(pattern, toSupplementaries("a...b"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
907 |
check(pattern, toSupplementaries("axxxb"), false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
908 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
909 |
flags |= Pattern.CANON_EQ; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
910 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
911 |
String t = toSupplementaries("test"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
912 |
p = Pattern.compile(t + "a\u030a", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
913 |
check(pattern, t + "a\u030a", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
914 |
check(pattern, t + "\u00e5", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
915 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
916 |
report("Literal pattern"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
917 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
918 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
919 |
// This test is for 4803179 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
920 |
// This test is also for 4808962, replacement parts |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
921 |
private static void literalReplacementTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
922 |
int flags = Pattern.LITERAL; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
923 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
924 |
Pattern pattern = Pattern.compile("abc", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
925 |
Matcher matcher = pattern.matcher("zzzabczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
926 |
String replaceTest = "$0"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
927 |
String result = matcher.replaceAll(replaceTest); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
928 |
if (!result.equals("zzzabczzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
929 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
930 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
931 |
matcher.reset(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
932 |
String literalReplacement = matcher.quoteReplacement(replaceTest); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
933 |
result = matcher.replaceAll(literalReplacement); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
934 |
if (!result.equals("zzz$0zzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
935 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
936 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
937 |
matcher.reset(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
938 |
replaceTest = "\\t$\\$"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
939 |
literalReplacement = matcher.quoteReplacement(replaceTest); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
940 |
result = matcher.replaceAll(literalReplacement); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
941 |
if (!result.equals("zzz\\t$\\$zzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
942 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
943 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
944 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
945 |
pattern = Pattern.compile(toSupplementaries("abc"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
946 |
matcher = pattern.matcher(toSupplementaries("zzzabczzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
947 |
replaceTest = "$0"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
948 |
result = matcher.replaceAll(replaceTest); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
949 |
if (!result.equals(toSupplementaries("zzzabczzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
950 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
951 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
952 |
matcher.reset(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
953 |
literalReplacement = matcher.quoteReplacement(replaceTest); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
954 |
result = matcher.replaceAll(literalReplacement); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
955 |
if (!result.equals(toSupplementaries("zzz$0zzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
956 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
957 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
958 |
matcher.reset(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
959 |
replaceTest = "\\t$\\$"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
960 |
literalReplacement = matcher.quoteReplacement(replaceTest); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
961 |
result = matcher.replaceAll(literalReplacement); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
962 |
if (!result.equals(toSupplementaries("zzz\\t$\\$zzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
963 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
964 |
|
12432
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
965 |
// IAE should be thrown if backslash or '$' is the last character |
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
966 |
// in replacement string |
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
967 |
try { |
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
968 |
"\uac00".replaceAll("\uac00", "$"); |
12675
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
969 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
970 |
} catch (IllegalArgumentException iie) { |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
971 |
} catch (Exception e) { |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
972 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
973 |
} |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
974 |
try { |
12432
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
975 |
"\uac00".replaceAll("\uac00", "\\"); |
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
976 |
failCount++; |
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
977 |
} catch (IllegalArgumentException iie) { |
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
978 |
} catch (Exception e) { |
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
979 |
failCount++; |
748fcaa0e0c1
7067045: replaceAll("\u20ac", "$"); causses java.lang.StringIndexOutOfBoundsExceptio
sherman
parents:
11287
diff
changeset
|
980 |
} |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
981 |
report("Literal replacement"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
982 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
983 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
984 |
// This test is for 4757029 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
985 |
private static void regionTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
986 |
Pattern pattern = Pattern.compile("abc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
987 |
Matcher matcher = pattern.matcher("abcdefabc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
988 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
989 |
matcher.region(0,9); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
990 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
991 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
992 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
993 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
994 |
matcher.region(0,3); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
995 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
996 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
997 |
matcher.region(3,6); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
998 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
999 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1000 |
matcher.region(0,2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1001 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1002 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1003 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1004 |
expectRegionFail(matcher, 1, -1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1005 |
expectRegionFail(matcher, -1, -1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1006 |
expectRegionFail(matcher, -1, 1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1007 |
expectRegionFail(matcher, 5, 3); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1008 |
expectRegionFail(matcher, 5, 12); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1009 |
expectRegionFail(matcher, 12, 12); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1010 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1011 |
pattern = Pattern.compile("^abc$"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1012 |
matcher = pattern.matcher("zzzabczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1013 |
matcher.region(0,9); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1014 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1015 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1016 |
matcher.region(3,6); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1017 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1018 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1019 |
matcher.region(3,6); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1020 |
matcher.useAnchoringBounds(false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1021 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1022 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1023 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1024 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1025 |
pattern = Pattern.compile(toSupplementaries("abc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1026 |
matcher = pattern.matcher(toSupplementaries("abcdefabc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1027 |
matcher.region(0,9*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1028 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1029 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1030 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1031 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1032 |
matcher.region(0,3*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1033 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1034 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1035 |
matcher.region(1,3*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1036 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1037 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1038 |
matcher.region(3*2,6*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1039 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1040 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1041 |
matcher.region(0,2*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1042 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1043 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1044 |
matcher.region(0,2*2+1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1045 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1046 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1047 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1048 |
expectRegionFail(matcher, 1*2, -1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1049 |
expectRegionFail(matcher, -1, -1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1050 |
expectRegionFail(matcher, -1, 1*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1051 |
expectRegionFail(matcher, 5*2, 3*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1052 |
expectRegionFail(matcher, 5*2, 12*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1053 |
expectRegionFail(matcher, 12*2, 12*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1054 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1055 |
pattern = Pattern.compile(toSupplementaries("^abc$")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1056 |
matcher = pattern.matcher(toSupplementaries("zzzabczzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1057 |
matcher.region(0,9*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1058 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1059 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1060 |
matcher.region(3*2,6*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1061 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1062 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1063 |
matcher.region(3*2+1,6*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1064 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1065 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1066 |
matcher.region(3*2,6*2-1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1067 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1068 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1069 |
matcher.region(3*2,6*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1070 |
matcher.useAnchoringBounds(false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1071 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1072 |
failCount++; |
58111
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1073 |
|
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1074 |
// JDK-8230829 |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1075 |
pattern = Pattern.compile("\\ud800\\udc61"); |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1076 |
matcher = pattern.matcher("\ud800\udc61"); |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1077 |
matcher.region(0, 1); |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1078 |
if (matcher.find()) { |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1079 |
failCount++; |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1080 |
System.out.println("Matched a surrogate pair" + |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1081 |
" that crosses border of region"); |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1082 |
} |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1083 |
if (!matcher.hitEnd()) { |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1084 |
failCount++; |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1085 |
System.out.println("Expected to hit the end when" + |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1086 |
" matching a surrogate pair crossing region"); |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1087 |
} |
f63f50a4bf43
8230829: Matcher matches a surrogate pair that crosses border of the region
igerasim
parents:
57624
diff
changeset
|
1088 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1089 |
report("Regions"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1090 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1091 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1092 |
private static void expectRegionFail(Matcher matcher, int index1, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1093 |
int index2) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1094 |
{ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1095 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1096 |
matcher.region(index1, index2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1097 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1098 |
} catch (IndexOutOfBoundsException ioobe) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1099 |
// Correct result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1100 |
} catch (IllegalStateException ise) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1101 |
// Correct result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1102 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1103 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1104 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1105 |
// This test is for 4803197 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1106 |
private static void escapedSegmentTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1107 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1108 |
Pattern pattern = Pattern.compile("\\Qdir1\\dir2\\E"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1109 |
check(pattern, "dir1\\dir2", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1110 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1111 |
pattern = Pattern.compile("\\Qdir1\\dir2\\\\E"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1112 |
check(pattern, "dir1\\dir2\\", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1113 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1114 |
pattern = Pattern.compile("(\\Qdir1\\dir2\\\\E)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1115 |
check(pattern, "dir1\\dir2\\", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1116 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1117 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1118 |
pattern = Pattern.compile(toSupplementaries("\\Qdir1\\dir2\\E")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1119 |
check(pattern, toSupplementaries("dir1\\dir2"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1120 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1121 |
pattern = Pattern.compile(toSupplementaries("\\Qdir1\\dir2")+"\\\\E"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1122 |
check(pattern, toSupplementaries("dir1\\dir2\\"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1123 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1124 |
pattern = Pattern.compile(toSupplementaries("(\\Qdir1\\dir2")+"\\\\E)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1125 |
check(pattern, toSupplementaries("dir1\\dir2\\"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1126 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1127 |
report("Escaped segment"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1128 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1129 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1130 |
// This test is for 4792284 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1131 |
private static void nonCaptureRepetitionTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1132 |
String input = "abcdefgh;"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1133 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1134 |
String[] patterns = new String[] { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1135 |
"(?:\\w{4})+;", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1136 |
"(?:\\w{8})*;", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1137 |
"(?:\\w{2}){2,4};", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1138 |
"(?:\\w{4}){2,};", // only matches the |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1139 |
".*?(?:\\w{5})+;", // specified minimum |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1140 |
".*?(?:\\w{9})*;", // number of reps - OK |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1141 |
"(?:\\w{4})+?;", // lazy repetition - OK |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1142 |
"(?:\\w{4})++;", // possessive repetition - OK |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1143 |
"(?:\\w{2,}?)+;", // non-deterministic - OK |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1144 |
"(\\w{4})+;", // capturing group - OK |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1145 |
}; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1146 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1147 |
for (int i = 0; i < patterns.length; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1148 |
// Check find() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1149 |
check(patterns[i], 0, input, input, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1150 |
// Check matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1151 |
Pattern p = Pattern.compile(patterns[i]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1152 |
Matcher m = p.matcher(input); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1153 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1154 |
if (m.matches()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1155 |
if (!m.group(0).equals(input)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1156 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1157 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1158 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1159 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1160 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1161 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1162 |
report("Non capturing repetition"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1163 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1164 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1165 |
// This test is for 6358731 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1166 |
private static void notCapturedGroupCurlyMatchTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1167 |
Pattern pattern = Pattern.compile("(abc)+|(abcd)+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1168 |
Matcher matcher = pattern.matcher("abcd"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1169 |
if (!matcher.matches() || |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1170 |
matcher.group(1) != null || |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1171 |
!matcher.group(2).equals("abcd")) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1172 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1173 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1174 |
report("Not captured GroupCurly"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1175 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1176 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1177 |
// This test is for 4706545 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1178 |
private static void javaCharClassTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1179 |
for (int i=0; i<1000; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1180 |
char c = (char)generator.nextInt(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1181 |
check("{javaLowerCase}", c, Character.isLowerCase(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1182 |
check("{javaUpperCase}", c, Character.isUpperCase(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1183 |
check("{javaUpperCase}+", c, Character.isUpperCase(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1184 |
check("{javaTitleCase}", c, Character.isTitleCase(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1185 |
check("{javaDigit}", c, Character.isDigit(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1186 |
check("{javaDefined}", c, Character.isDefined(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1187 |
check("{javaLetter}", c, Character.isLetter(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1188 |
check("{javaLetterOrDigit}", c, Character.isLetterOrDigit(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1189 |
check("{javaJavaIdentifierStart}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1190 |
Character.isJavaIdentifierStart(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1191 |
check("{javaJavaIdentifierPart}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1192 |
Character.isJavaIdentifierPart(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1193 |
check("{javaUnicodeIdentifierStart}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1194 |
Character.isUnicodeIdentifierStart(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1195 |
check("{javaUnicodeIdentifierPart}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1196 |
Character.isUnicodeIdentifierPart(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1197 |
check("{javaIdentifierIgnorable}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1198 |
Character.isIdentifierIgnorable(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1199 |
check("{javaSpaceChar}", c, Character.isSpaceChar(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1200 |
check("{javaWhitespace}", c, Character.isWhitespace(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1201 |
check("{javaISOControl}", c, Character.isISOControl(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1202 |
check("{javaMirrored}", c, Character.isMirrored(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1203 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1204 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1205 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1206 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1207 |
for (int i=0; i<1000; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1208 |
int c = generator.nextInt(Character.MAX_CODE_POINT |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1209 |
- Character.MIN_SUPPLEMENTARY_CODE_POINT) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1210 |
+ Character.MIN_SUPPLEMENTARY_CODE_POINT; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1211 |
check("{javaLowerCase}", c, Character.isLowerCase(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1212 |
check("{javaUpperCase}", c, Character.isUpperCase(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1213 |
check("{javaUpperCase}+", c, Character.isUpperCase(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1214 |
check("{javaTitleCase}", c, Character.isTitleCase(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1215 |
check("{javaDigit}", c, Character.isDigit(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1216 |
check("{javaDefined}", c, Character.isDefined(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1217 |
check("{javaLetter}", c, Character.isLetter(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1218 |
check("{javaLetterOrDigit}", c, Character.isLetterOrDigit(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1219 |
check("{javaJavaIdentifierStart}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1220 |
Character.isJavaIdentifierStart(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1221 |
check("{javaJavaIdentifierPart}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1222 |
Character.isJavaIdentifierPart(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1223 |
check("{javaUnicodeIdentifierStart}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1224 |
Character.isUnicodeIdentifierStart(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1225 |
check("{javaUnicodeIdentifierPart}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1226 |
Character.isUnicodeIdentifierPart(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1227 |
check("{javaIdentifierIgnorable}", c, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1228 |
Character.isIdentifierIgnorable(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1229 |
check("{javaSpaceChar}", c, Character.isSpaceChar(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1230 |
check("{javaWhitespace}", c, Character.isWhitespace(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1231 |
check("{javaISOControl}", c, Character.isISOControl(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1232 |
check("{javaMirrored}", c, Character.isMirrored(c)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1233 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1234 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1235 |
report("Java character classes"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1236 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1237 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1238 |
// This test is for 4523620 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1239 |
/* |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1240 |
private static void numOccurrencesTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1241 |
Pattern pattern = Pattern.compile("aaa"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1242 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1243 |
if (pattern.numOccurrences("aaaaaa", false) != 2) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1244 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1245 |
if (pattern.numOccurrences("aaaaaa", true) != 4) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1246 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1247 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1248 |
pattern = Pattern.compile("^"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1249 |
if (pattern.numOccurrences("aaaaaa", false) != 1) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1250 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1251 |
if (pattern.numOccurrences("aaaaaa", true) != 1) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1252 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1253 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1254 |
report("Number of Occurrences"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1255 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1256 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1257 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1258 |
// This test is for 4776374 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1259 |
private static void caretBetweenTerminatorsTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1260 |
int flags1 = Pattern.DOTALL; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1261 |
int flags2 = Pattern.DOTALL | Pattern.UNIX_LINES; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1262 |
int flags3 = Pattern.DOTALL | Pattern.UNIX_LINES | Pattern.MULTILINE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1263 |
int flags4 = Pattern.DOTALL | Pattern.MULTILINE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1264 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1265 |
check("^....", flags1, "test\ntest", "test", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1266 |
check(".....^", flags1, "test\ntest", "test", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1267 |
check(".....^", flags1, "test\n", "test", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1268 |
check("....^", flags1, "test\r\n", "test", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1269 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1270 |
check("^....", flags2, "test\ntest", "test", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1271 |
check("....^", flags2, "test\ntest", "test", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1272 |
check(".....^", flags2, "test\n", "test", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1273 |
check("....^", flags2, "test\r\n", "test", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1274 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1275 |
check("^....", flags3, "test\ntest", "test", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1276 |
check(".....^", flags3, "test\ntest", "test\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1277 |
check(".....^", flags3, "test\u0085test", "test\u0085", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1278 |
check(".....^", flags3, "test\n", "test", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1279 |
check(".....^", flags3, "test\r\n", "test", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1280 |
check("......^", flags3, "test\r\ntest", "test\r\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1281 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1282 |
check("^....", flags4, "test\ntest", "test", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1283 |
check(".....^", flags3, "test\ntest", "test\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1284 |
check(".....^", flags4, "test\u0085test", "test\u0085", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1285 |
check(".....^", flags4, "test\n", "test\n", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1286 |
check(".....^", flags4, "test\r\n", "test\r", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1287 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1288 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1289 |
String t = toSupplementaries("test"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1290 |
check("^....", flags1, t+"\n"+t, t, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1291 |
check(".....^", flags1, t+"\n"+t, t, false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1292 |
check(".....^", flags1, t+"\n", t, false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1293 |
check("....^", flags1, t+"\r\n", t, false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1294 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1295 |
check("^....", flags2, t+"\n"+t, t, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1296 |
check("....^", flags2, t+"\n"+t, t, false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1297 |
check(".....^", flags2, t+"\n", t, false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1298 |
check("....^", flags2, t+"\r\n", t, false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1299 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1300 |
check("^....", flags3, t+"\n"+t, t, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1301 |
check(".....^", flags3, t+"\n"+t, t+"\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1302 |
check(".....^", flags3, t+"\u0085"+t, t+"\u0085", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1303 |
check(".....^", flags3, t+"\n", t, false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1304 |
check(".....^", flags3, t+"\r\n", t, false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1305 |
check("......^", flags3, t+"\r\n"+t, t+"\r\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1306 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1307 |
check("^....", flags4, t+"\n"+t, t, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1308 |
check(".....^", flags3, t+"\n"+t, t+"\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1309 |
check(".....^", flags4, t+"\u0085"+t, t+"\u0085", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1310 |
check(".....^", flags4, t+"\n", t+"\n", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1311 |
check(".....^", flags4, t+"\r\n", t+"\r", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1312 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1313 |
report("Caret between terminators"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1314 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1315 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1316 |
// This test is for 4727935 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1317 |
private static void dollarAtEndTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1318 |
int flags1 = Pattern.DOTALL; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1319 |
int flags2 = Pattern.DOTALL | Pattern.UNIX_LINES; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1320 |
int flags3 = Pattern.DOTALL | Pattern.MULTILINE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1321 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1322 |
check("....$", flags1, "test\n", "test", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1323 |
check("....$", flags1, "test\r\n", "test", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1324 |
check(".....$", flags1, "test\n", "test\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1325 |
check(".....$", flags1, "test\u0085", "test\u0085", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1326 |
check("....$", flags1, "test\u0085", "test", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1327 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1328 |
check("....$", flags2, "test\n", "test", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1329 |
check(".....$", flags2, "test\n", "test\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1330 |
check(".....$", flags2, "test\u0085", "test\u0085", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1331 |
check("....$", flags2, "test\u0085", "est\u0085", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1332 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1333 |
check("....$.blah", flags3, "test\nblah", "test\nblah", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1334 |
check(".....$.blah", flags3, "test\n\nblah", "test\n\nblah", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1335 |
check("....$blah", flags3, "test\nblah", "!!!!", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1336 |
check(".....$blah", flags3, "test\nblah", "!!!!", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1337 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1338 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1339 |
String t = toSupplementaries("test"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1340 |
String b = toSupplementaries("blah"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1341 |
check("....$", flags1, t+"\n", t, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1342 |
check("....$", flags1, t+"\r\n", t, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1343 |
check(".....$", flags1, t+"\n", t+"\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1344 |
check(".....$", flags1, t+"\u0085", t+"\u0085", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1345 |
check("....$", flags1, t+"\u0085", t, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1346 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1347 |
check("....$", flags2, t+"\n", t, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1348 |
check(".....$", flags2, t+"\n", t+"\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1349 |
check(".....$", flags2, t+"\u0085", t+"\u0085", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1350 |
check("....$", flags2, t+"\u0085", toSupplementaries("est\u0085"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1351 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1352 |
check("....$."+b, flags3, t+"\n"+b, t+"\n"+b, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1353 |
check(".....$."+b, flags3, t+"\n\n"+b, t+"\n\n"+b, true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1354 |
check("....$"+b, flags3, t+"\n"+b, "!!!!", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1355 |
check(".....$"+b, flags3, t+"\n"+b, "!!!!", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1356 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1357 |
report("Dollar at End"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1358 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1359 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1360 |
// This test is for 4711773 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1361 |
private static void multilineDollarTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1362 |
Pattern findCR = Pattern.compile("$", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1363 |
Matcher matcher = findCR.matcher("first bit\nsecond bit"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1364 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1365 |
if (matcher.start(0) != 9) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1366 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1367 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1368 |
if (matcher.start(0) != 20) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1369 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1370 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1371 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1372 |
matcher = findCR.matcher(toSupplementaries("first bit\n second bit")); // double BMP chars |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1373 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1374 |
if (matcher.start(0) != 9*2) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1375 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1376 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1377 |
if (matcher.start(0) != 20*2) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1378 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1379 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1380 |
report("Multiline Dollar"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1381 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1382 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1383 |
private static void reluctantRepetitionTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1384 |
Pattern p = Pattern.compile("1(\\s\\S+?){1,3}?[\\s,]2"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1385 |
check(p, "1 word word word 2", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1386 |
check(p, "1 wor wo w 2", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1387 |
check(p, "1 word word 2", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1388 |
check(p, "1 word 2", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1389 |
check(p, "1 wo w w 2", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1390 |
check(p, "1 wo w 2", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1391 |
check(p, "1 wor w 2", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1392 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1393 |
p = Pattern.compile("([a-z])+?c"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1394 |
Matcher m = p.matcher("ababcdefdec"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1395 |
check(m, "ababc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1396 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1397 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1398 |
p = Pattern.compile(toSupplementaries("([a-z])+?c")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1399 |
m = p.matcher(toSupplementaries("ababcdefdec")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1400 |
check(m, toSupplementaries("ababc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1401 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1402 |
report("Reluctant Repetition"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1403 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1404 |
|
48491
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1405 |
private static Pattern serializedPattern(Pattern p) throws Exception { |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1406 |
ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1407 |
ObjectOutputStream oos = new ObjectOutputStream(baos); |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1408 |
oos.writeObject(p); |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1409 |
oos.close(); |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1410 |
try (ObjectInputStream ois = new ObjectInputStream( |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1411 |
new ByteArrayInputStream(baos.toByteArray()))) { |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1412 |
return (Pattern)ois.readObject(); |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1413 |
} |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1414 |
} |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1415 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1416 |
private static void serializeTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1417 |
String patternStr = "(b)"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1418 |
String matchStr = "b"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1419 |
Pattern pattern = Pattern.compile(patternStr); |
48491
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1420 |
Pattern serializedPattern = serializedPattern(pattern); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1421 |
Matcher matcher = serializedPattern.matcher(matchStr); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1422 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1423 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1424 |
if (matcher.groupCount() != 1) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1425 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1426 |
|
48491
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1427 |
pattern = Pattern.compile("a(?-i)b", Pattern.CASE_INSENSITIVE); |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1428 |
serializedPattern = serializedPattern(pattern); |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1429 |
if (!serializedPattern.matcher("Ab").matches()) |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1430 |
failCount++; |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1431 |
if (serializedPattern.matcher("AB").matches()) |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1432 |
failCount++; |
7f11a1699ef6
8194667: Regex: Serialization doesn't work with match flags
sherman
parents:
47216
diff
changeset
|
1433 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1434 |
report("Serialization"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1435 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1436 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1437 |
private static void gTest() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1438 |
Pattern pattern = Pattern.compile("\\G\\w"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1439 |
Matcher matcher = pattern.matcher("abc#x#x"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1440 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1441 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1442 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1443 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1444 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1445 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1446 |
pattern = Pattern.compile("\\GA*"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1447 |
matcher = pattern.matcher("1A2AA3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1448 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1449 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1450 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1451 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1452 |
pattern = Pattern.compile("\\GA*"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1453 |
matcher = pattern.matcher("1A2AA3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1454 |
if (!matcher.find(1)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1455 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1456 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1457 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1458 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1459 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1460 |
report("\\G"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1461 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1462 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1463 |
private static void zTest() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1464 |
Pattern pattern = Pattern.compile("foo\\Z"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1465 |
// Positives |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1466 |
check(pattern, "foo\u0085", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1467 |
check(pattern, "foo\u2028", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1468 |
check(pattern, "foo\u2029", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1469 |
check(pattern, "foo\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1470 |
check(pattern, "foo\r", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1471 |
check(pattern, "foo\r\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1472 |
// Negatives |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1473 |
check(pattern, "fooo", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1474 |
check(pattern, "foo\n\r", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1475 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1476 |
pattern = Pattern.compile("foo\\Z", Pattern.UNIX_LINES); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1477 |
// Positives |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1478 |
check(pattern, "foo", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1479 |
check(pattern, "foo\n", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1480 |
// Negatives |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1481 |
check(pattern, "foo\r", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1482 |
check(pattern, "foo\u0085", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1483 |
check(pattern, "foo\u2028", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1484 |
check(pattern, "foo\u2029", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1485 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1486 |
report("\\Z"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1487 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1488 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1489 |
private static void replaceFirstTest() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1490 |
Pattern pattern = Pattern.compile("(ab)(c*)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1491 |
Matcher matcher = pattern.matcher("abccczzzabcczzzabccc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1492 |
if (!matcher.replaceFirst("test").equals("testzzzabcczzzabccc")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1493 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1494 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1495 |
matcher.reset("zzzabccczzzabcczzzabccczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1496 |
if (!matcher.replaceFirst("test").equals("zzztestzzzabcczzzabccczzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1497 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1498 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1499 |
matcher.reset("zzzabccczzzabcczzzabccczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1500 |
String result = matcher.replaceFirst("$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1501 |
if (!result.equals("zzzabzzzabcczzzabccczzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1502 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1503 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1504 |
matcher.reset("zzzabccczzzabcczzzabccczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1505 |
result = matcher.replaceFirst("$2"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1506 |
if (!result.equals("zzzccczzzabcczzzabccczzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1507 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1508 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1509 |
pattern = Pattern.compile("a*"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1510 |
matcher = pattern.matcher("aaaaaaaaaa"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1511 |
if (!matcher.replaceFirst("test").equals("test")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1512 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1513 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1514 |
pattern = Pattern.compile("a+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1515 |
matcher = pattern.matcher("zzzaaaaaaaaaa"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1516 |
if (!matcher.replaceFirst("test").equals("zzztest")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1517 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1518 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1519 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1520 |
pattern = Pattern.compile(toSupplementaries("(ab)(c*)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1521 |
matcher = pattern.matcher(toSupplementaries("abccczzzabcczzzabccc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1522 |
if (!matcher.replaceFirst(toSupplementaries("test")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1523 |
.equals(toSupplementaries("testzzzabcczzzabccc"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1524 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1525 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1526 |
matcher.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1527 |
if (!matcher.replaceFirst(toSupplementaries("test")). |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1528 |
equals(toSupplementaries("zzztestzzzabcczzzabccczzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1529 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1530 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1531 |
matcher.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1532 |
result = matcher.replaceFirst("$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1533 |
if (!result.equals(toSupplementaries("zzzabzzzabcczzzabccczzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1534 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1535 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1536 |
matcher.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1537 |
result = matcher.replaceFirst("$2"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1538 |
if (!result.equals(toSupplementaries("zzzccczzzabcczzzabccczzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1539 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1540 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1541 |
pattern = Pattern.compile(toSupplementaries("a*")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1542 |
matcher = pattern.matcher(toSupplementaries("aaaaaaaaaa")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1543 |
if (!matcher.replaceFirst(toSupplementaries("test")).equals(toSupplementaries("test"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1544 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1545 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1546 |
pattern = Pattern.compile(toSupplementaries("a+")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1547 |
matcher = pattern.matcher(toSupplementaries("zzzaaaaaaaaaa")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1548 |
if (!matcher.replaceFirst(toSupplementaries("test")).equals(toSupplementaries("zzztest"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1549 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1550 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1551 |
report("Replace First"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1552 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1553 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1554 |
private static void unixLinesTest() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1555 |
Pattern pattern = Pattern.compile(".*"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1556 |
Matcher matcher = pattern.matcher("aa\u2028blah"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1557 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1558 |
if (!matcher.group(0).equals("aa")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1559 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1560 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1561 |
pattern = Pattern.compile(".*", Pattern.UNIX_LINES); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1562 |
matcher = pattern.matcher("aa\u2028blah"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1563 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1564 |
if (!matcher.group(0).equals("aa\u2028blah")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1565 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1566 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1567 |
pattern = Pattern.compile("[az]$", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1568 |
Pattern.MULTILINE | Pattern.UNIX_LINES); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1569 |
matcher = pattern.matcher("aa\u2028zz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1570 |
check(matcher, "a\u2028", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1571 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1572 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1573 |
pattern = Pattern.compile(".*"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1574 |
matcher = pattern.matcher(toSupplementaries("aa\u2028blah")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1575 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1576 |
if (!matcher.group(0).equals(toSupplementaries("aa"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1577 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1578 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1579 |
pattern = Pattern.compile(".*", Pattern.UNIX_LINES); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1580 |
matcher = pattern.matcher(toSupplementaries("aa\u2028blah")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1581 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1582 |
if (!matcher.group(0).equals(toSupplementaries("aa\u2028blah"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1583 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1584 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1585 |
pattern = Pattern.compile(toSupplementaries("[az]$"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1586 |
Pattern.MULTILINE | Pattern.UNIX_LINES); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1587 |
matcher = pattern.matcher(toSupplementaries("aa\u2028zz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1588 |
check(matcher, toSupplementaries("a\u2028"), false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1589 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1590 |
report("Unix Lines"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1591 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1592 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1593 |
private static void commentsTest() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1594 |
int flags = Pattern.COMMENTS; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1595 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1596 |
Pattern pattern = Pattern.compile("aa \\# aa", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1597 |
Matcher matcher = pattern.matcher("aa#aa"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1598 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1599 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1600 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1601 |
pattern = Pattern.compile("aa # blah", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1602 |
matcher = pattern.matcher("aa"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1603 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1604 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1605 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1606 |
pattern = Pattern.compile("aa blah", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1607 |
matcher = pattern.matcher("aablah"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1608 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1609 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1610 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1611 |
pattern = Pattern.compile("aa # blah blech ", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1612 |
matcher = pattern.matcher("aa"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1613 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1614 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1615 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1616 |
pattern = Pattern.compile("aa # blah\n ", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1617 |
matcher = pattern.matcher("aa"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1618 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1619 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1620 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1621 |
pattern = Pattern.compile("aa # blah\nbc # blech", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1622 |
matcher = pattern.matcher("aabc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1623 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1624 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1625 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1626 |
pattern = Pattern.compile("aa # blah\nbc# blech", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1627 |
matcher = pattern.matcher("aabc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1628 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1629 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1630 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1631 |
pattern = Pattern.compile("aa # blah\nbc\\# blech", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1632 |
matcher = pattern.matcher("aabc#blech"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1633 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1634 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1635 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1636 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1637 |
pattern = Pattern.compile(toSupplementaries("aa \\# aa"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1638 |
matcher = pattern.matcher(toSupplementaries("aa#aa")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1639 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1640 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1641 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1642 |
pattern = Pattern.compile(toSupplementaries("aa # blah"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1643 |
matcher = pattern.matcher(toSupplementaries("aa")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1644 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1645 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1646 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1647 |
pattern = Pattern.compile(toSupplementaries("aa blah"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1648 |
matcher = pattern.matcher(toSupplementaries("aablah")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1649 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1650 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1651 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1652 |
pattern = Pattern.compile(toSupplementaries("aa # blah blech "), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1653 |
matcher = pattern.matcher(toSupplementaries("aa")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1654 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1655 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1656 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1657 |
pattern = Pattern.compile(toSupplementaries("aa # blah\n "), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1658 |
matcher = pattern.matcher(toSupplementaries("aa")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1659 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1660 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1661 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1662 |
pattern = Pattern.compile(toSupplementaries("aa # blah\nbc # blech"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1663 |
matcher = pattern.matcher(toSupplementaries("aabc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1664 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1665 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1666 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1667 |
pattern = Pattern.compile(toSupplementaries("aa # blah\nbc# blech"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1668 |
matcher = pattern.matcher(toSupplementaries("aabc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1669 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1670 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1671 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1672 |
pattern = Pattern.compile(toSupplementaries("aa # blah\nbc\\# blech"), flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1673 |
matcher = pattern.matcher(toSupplementaries("aabc#blech")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1674 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1675 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1676 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1677 |
report("Comments"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1678 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1679 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1680 |
private static void caseFoldingTest() { // bug 4504687 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1681 |
int flags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1682 |
Pattern pattern = Pattern.compile("aa", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1683 |
Matcher matcher = pattern.matcher("ab"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1684 |
if (matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1685 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1686 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1687 |
pattern = Pattern.compile("aA", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1688 |
matcher = pattern.matcher("ab"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1689 |
if (matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1690 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1691 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1692 |
pattern = Pattern.compile("aa", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1693 |
matcher = pattern.matcher("aB"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1694 |
if (matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1695 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1696 |
matcher = pattern.matcher("Ab"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1697 |
if (matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1698 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1699 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1700 |
// ASCII "a" |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1701 |
// Latin-1 Supplement "a" + grave |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1702 |
// Cyrillic "a" |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1703 |
String[] patterns = new String[] { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1704 |
//single |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1705 |
"a", "\u00e0", "\u0430", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1706 |
//slice |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1707 |
"ab", "\u00e0\u00e1", "\u0430\u0431", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1708 |
//class single |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1709 |
"[a]", "[\u00e0]", "[\u0430]", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1710 |
//class range |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1711 |
"[a-b]", "[\u00e0-\u00e5]", "[\u0430-\u0431]", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1712 |
//back reference |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1713 |
"(a)\\1", "(\u00e0)\\1", "(\u0430)\\1" |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1714 |
}; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1715 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1716 |
String[] texts = new String[] { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1717 |
"A", "\u00c0", "\u0410", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1718 |
"AB", "\u00c0\u00c1", "\u0410\u0411", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1719 |
"A", "\u00c0", "\u0410", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1720 |
"B", "\u00c2", "\u0411", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1721 |
"aA", "\u00e0\u00c0", "\u0430\u0410" |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1722 |
}; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1723 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1724 |
boolean[] expected = new boolean[] { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1725 |
true, false, false, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1726 |
true, false, false, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1727 |
true, false, false, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1728 |
true, false, false, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1729 |
true, false, false |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1730 |
}; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1731 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1732 |
flags = Pattern.CASE_INSENSITIVE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1733 |
for (int i = 0; i < patterns.length; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1734 |
pattern = Pattern.compile(patterns[i], flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1735 |
matcher = pattern.matcher(texts[i]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1736 |
if (matcher.matches() != expected[i]) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1737 |
System.out.println("<1> Failed at " + i); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1738 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1739 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1740 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1741 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1742 |
flags = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1743 |
for (int i = 0; i < patterns.length; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1744 |
pattern = Pattern.compile(patterns[i], flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1745 |
matcher = pattern.matcher(texts[i]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1746 |
if (!matcher.matches()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1747 |
System.out.println("<2> Failed at " + i); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1748 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1749 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1750 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1751 |
// flag unicode_case alone should do nothing |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1752 |
flags = Pattern.UNICODE_CASE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1753 |
for (int i = 0; i < patterns.length; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1754 |
pattern = Pattern.compile(patterns[i], flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1755 |
matcher = pattern.matcher(texts[i]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1756 |
if (matcher.matches()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1757 |
System.out.println("<3> Failed at " + i); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1758 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1759 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1760 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1761 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1762 |
// Special cases: i, I, u+0131 and u+0130 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1763 |
flags = Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1764 |
pattern = Pattern.compile("[h-j]+", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1765 |
if (!pattern.matcher("\u0131\u0130").matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1766 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1767 |
report("Case Folding"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1768 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1769 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1770 |
private static void appendTest() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1771 |
Pattern pattern = Pattern.compile("(ab)(cd)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1772 |
Matcher matcher = pattern.matcher("abcd"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1773 |
String result = matcher.replaceAll("$2$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1774 |
if (!result.equals("cdab")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1775 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1776 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1777 |
String s1 = "Swap all: first = 123, second = 456"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1778 |
String s2 = "Swap one: first = 123, second = 456"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1779 |
String r = "$3$2$1"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1780 |
pattern = Pattern.compile("([a-z]+)( *= *)([0-9]+)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1781 |
matcher = pattern.matcher(s1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1782 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1783 |
result = matcher.replaceAll(r); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1784 |
if (!result.equals("Swap all: 123 = first, 456 = second")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1785 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1786 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1787 |
matcher = pattern.matcher(s2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1788 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1789 |
if (matcher.find()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1790 |
StringBuffer sb = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1791 |
matcher.appendReplacement(sb, r); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1792 |
matcher.appendTail(sb); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1793 |
result = sb.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1794 |
if (!result.equals("Swap one: 123 = first, second = 456")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1795 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1796 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1797 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1798 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1799 |
pattern = Pattern.compile(toSupplementaries("(ab)(cd)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1800 |
matcher = pattern.matcher(toSupplementaries("abcd")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1801 |
result = matcher.replaceAll("$2$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1802 |
if (!result.equals(toSupplementaries("cdab"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1803 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1804 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1805 |
s1 = toSupplementaries("Swap all: first = 123, second = 456"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1806 |
s2 = toSupplementaries("Swap one: first = 123, second = 456"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1807 |
r = toSupplementaries("$3$2$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1808 |
pattern = Pattern.compile(toSupplementaries("([a-z]+)( *= *)([0-9]+)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1809 |
matcher = pattern.matcher(s1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1810 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1811 |
result = matcher.replaceAll(r); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1812 |
if (!result.equals(toSupplementaries("Swap all: 123 = first, 456 = second"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1813 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1814 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1815 |
matcher = pattern.matcher(s2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1816 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1817 |
if (matcher.find()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1818 |
StringBuffer sb = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1819 |
matcher.appendReplacement(sb, r); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1820 |
matcher.appendTail(sb); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1821 |
result = sb.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1822 |
if (!result.equals(toSupplementaries("Swap one: 123 = first, second = 456"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1823 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1824 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1825 |
report("Append"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1826 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1827 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1828 |
private static void splitTest() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1829 |
Pattern pattern = Pattern.compile(":"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1830 |
String[] result = pattern.split("foo:and:boo", 2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1831 |
if (!result[0].equals("foo")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1832 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1833 |
if (!result[1].equals("and:boo")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1834 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1835 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1836 |
Pattern patternX = Pattern.compile(toSupplementaries("X")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1837 |
result = patternX.split(toSupplementaries("fooXandXboo"), 2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1838 |
if (!result[0].equals(toSupplementaries("foo"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1839 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1840 |
if (!result[1].equals(toSupplementaries("andXboo"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1841 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1842 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1843 |
CharBuffer cb = CharBuffer.allocate(100); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1844 |
cb.put("foo:and:boo"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1845 |
cb.flip(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1846 |
result = pattern.split(cb); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1847 |
if (!result[0].equals("foo")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1848 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1849 |
if (!result[1].equals("and")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1850 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1851 |
if (!result[2].equals("boo")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1852 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1853 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1854 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1855 |
CharBuffer cbs = CharBuffer.allocate(100); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1856 |
cbs.put(toSupplementaries("fooXandXboo")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1857 |
cbs.flip(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1858 |
result = patternX.split(cbs); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1859 |
if (!result[0].equals(toSupplementaries("foo"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1860 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1861 |
if (!result[1].equals(toSupplementaries("and"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1862 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1863 |
if (!result[2].equals(toSupplementaries("boo"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1864 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1865 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1866 |
String source = "0123456789"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1867 |
for (int limit=-2; limit<3; limit++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1868 |
for (int x=0; x<10; x++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1869 |
result = source.split(Integer.toString(x), limit); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1870 |
int expectedLength = limit < 1 ? 2 : limit; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1871 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1872 |
if ((limit == 0) && (x == 9)) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1873 |
// expected dropping of "" |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1874 |
if (result.length != 1) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1875 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1876 |
if (!result[0].equals("012345678")) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1877 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1878 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1879 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1880 |
if (result.length != expectedLength) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1881 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1882 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1883 |
if (!result[0].equals(source.substring(0,x))) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1884 |
if (limit != 1) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1885 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1886 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1887 |
if (!result[0].equals(source.substring(0,10))) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1888 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1889 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1890 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1891 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1892 |
if (expectedLength > 1) { // Check segment 2 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1893 |
if (!result[1].equals(source.substring(x+1,10))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1894 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1895 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1896 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1897 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1898 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1899 |
// Check the case for no match found |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1900 |
for (int limit=-2; limit<3; limit++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1901 |
result = source.split("e", limit); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1902 |
if (result.length != 1) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1903 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1904 |
if (!result[0].equals(source)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1905 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1906 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1907 |
// Check the case for limit == 0, source = ""; |
21668 | 1908 |
// split() now returns 0-length for empty source "" see #6559590 |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1909 |
source = ""; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1910 |
result = source.split("e", 0); |
21670
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1911 |
if (result.length != 1) |
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1912 |
failCount++; |
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1913 |
if (!result[0].equals(source)) |
21668 | 1914 |
failCount++; |
1915 |
||
1916 |
// Check both split() and splitAsStraem(), especially for zero-lenth |
|
1917 |
// input and zero-lenth match cases |
|
1918 |
String[][] input = new String[][] { |
|
1919 |
{ " ", "Abc Efg Hij" }, // normal non-zero-match |
|
1920 |
{ " ", " Abc Efg Hij" }, // leading empty str for non-zero-match |
|
1921 |
{ " ", "Abc Efg Hij" }, // non-zero-match in the middle |
|
1922 |
{ "(?=\\p{Lu})", "AbcEfgHij" }, // no leading empty str for zero-match |
|
1923 |
{ "(?=\\p{Lu})", "AbcEfg" }, |
|
1924 |
{ "(?=\\p{Lu})", "Abc" }, |
|
1925 |
{ " ", "" }, // zero-length input |
|
1926 |
{ ".*", "" }, |
|
1927 |
||
1928 |
// some tests from PatternStreamTest.java |
|
1929 |
{ "4", "awgqwefg1fefw4vssv1vvv1" }, |
|
1930 |
{ "\u00a3a", "afbfq\u00a3abgwgb\u00a3awngnwggw\u00a3a\u00a3ahjrnhneerh" }, |
|
1931 |
{ "1", "awgqwefg1fefw4vssv1vvv1" }, |
|
1932 |
{ "1", "a\u4ebafg1fefw\u4eba4\u9f9cvssv\u9f9c1v\u672c\u672cvv" }, |
|
1933 |
{ "\u56da", "1\u56da23\u56da456\u56da7890" }, |
|
1934 |
{ "\u56da", "1\u56da23\u9f9c\u672c\u672c\u56da456\u56da\u9f9c\u672c7890" }, |
|
1935 |
{ "\u56da", "" }, |
|
1936 |
{ "[ \t,:.]","This is,testing: with\tdifferent separators." }, //multiple septs |
|
1937 |
{ "o", "boo:and:foo" }, |
|
1938 |
{ "o", "booooo:and:fooooo" }, |
|
1939 |
{ "o", "fooooo:" }, |
|
1940 |
}; |
|
1941 |
||
1942 |
String[][] expected = new String[][] { |
|
1943 |
{ "Abc", "Efg", "Hij" }, |
|
1944 |
{ "", "Abc", "Efg", "Hij" }, |
|
1945 |
{ "Abc", "", "Efg", "Hij" }, |
|
1946 |
{ "Abc", "Efg", "Hij" }, |
|
1947 |
{ "Abc", "Efg" }, |
|
1948 |
{ "Abc" }, |
|
21670
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1949 |
{ "" }, |
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1950 |
{ "" }, |
21668 | 1951 |
|
1952 |
{ "awgqwefg1fefw", "vssv1vvv1" }, |
|
1953 |
{ "afbfq", "bgwgb", "wngnwggw", "", "hjrnhneerh" }, |
|
1954 |
{ "awgqwefg", "fefw4vssv", "vvv" }, |
|
1955 |
{ "a\u4ebafg", "fefw\u4eba4\u9f9cvssv\u9f9c", "v\u672c\u672cvv" }, |
|
1956 |
{ "1", "23", "456", "7890" }, |
|
1957 |
{ "1", "23\u9f9c\u672c\u672c", "456", "\u9f9c\u672c7890" }, |
|
21670
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1958 |
{ "" }, |
21668 | 1959 |
{ "This", "is", "testing", "", "with", "different", "separators" }, |
1960 |
{ "b", "", ":and:f" }, |
|
1961 |
{ "b", "", "", "", "", ":and:f" }, |
|
1962 |
{ "f", "", "", "", "", ":" }, |
|
1963 |
}; |
|
1964 |
for (int i = 0; i < input.length; i++) { |
|
1965 |
pattern = Pattern.compile(input[i][0]); |
|
21670
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1966 |
if (!Arrays.equals(pattern.split(input[i][1]), expected[i])) { |
21668 | 1967 |
failCount++; |
21670
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1968 |
} |
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1969 |
if (input[i][1].length() > 0 && // splitAsStream() return empty resulting |
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1970 |
// array for zero-length input for now |
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1971 |
!Arrays.equals(pattern.splitAsStream(input[i][1]).toArray(), |
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1972 |
expected[i])) { |
21668 | 1973 |
failCount++; |
21670
ca3553133ede
8028321: Fix for String.split() empty input sequence/JDK-6559590 triggers regression
sherman
parents:
21668
diff
changeset
|
1974 |
} |
21668 | 1975 |
} |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1976 |
report("Split"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1977 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1978 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1979 |
private static void negationTest() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1980 |
Pattern pattern = Pattern.compile("[\\[@^]+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1981 |
Matcher matcher = pattern.matcher("@@@@[[[[^^^^"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1982 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1983 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1984 |
if (!matcher.group(0).equals("@@@@[[[[^^^^")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1985 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1986 |
pattern = Pattern.compile("[@\\[^]+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1987 |
matcher = pattern.matcher("@@@@[[[[^^^^"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1988 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1989 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1990 |
if (!matcher.group(0).equals("@@@@[[[[^^^^")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1991 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1992 |
pattern = Pattern.compile("[@\\[^@]+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1993 |
matcher = pattern.matcher("@@@@[[[[^^^^"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1994 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1995 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1996 |
if (!matcher.group(0).equals("@@@@[[[[^^^^")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1997 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1998 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
1999 |
pattern = Pattern.compile("\\)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2000 |
matcher = pattern.matcher("xxx)xxx"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2001 |
if (!matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2002 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2003 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2004 |
report("Negation"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2005 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2006 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2007 |
private static void ampersandTest() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2008 |
Pattern pattern = Pattern.compile("[&@]+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2009 |
check(pattern, "@@@@&&&&", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2010 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2011 |
pattern = Pattern.compile("[@&]+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2012 |
check(pattern, "@@@@&&&&", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2013 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2014 |
pattern = Pattern.compile("[@\\&]+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2015 |
check(pattern, "@@@@&&&&", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2016 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2017 |
report("Ampersand"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2018 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2019 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2020 |
private static void octalTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2021 |
Pattern pattern = Pattern.compile("\\u0007"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2022 |
Matcher matcher = pattern.matcher("\u0007"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2023 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2024 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2025 |
pattern = Pattern.compile("\\07"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2026 |
matcher = pattern.matcher("\u0007"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2027 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2028 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2029 |
pattern = Pattern.compile("\\007"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2030 |
matcher = pattern.matcher("\u0007"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2031 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2032 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2033 |
pattern = Pattern.compile("\\0007"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2034 |
matcher = pattern.matcher("\u0007"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2035 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2036 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2037 |
pattern = Pattern.compile("\\040"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2038 |
matcher = pattern.matcher("\u0020"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2039 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2040 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2041 |
pattern = Pattern.compile("\\0403"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2042 |
matcher = pattern.matcher("\u00203"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2043 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2044 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2045 |
pattern = Pattern.compile("\\0103"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2046 |
matcher = pattern.matcher("\u0043"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2047 |
if (!matcher.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2048 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2049 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2050 |
report("Octal"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2051 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2052 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2053 |
private static void longPatternTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2054 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2055 |
Pattern pattern = Pattern.compile( |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2056 |
"a 32-character-long pattern xxxx"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2057 |
pattern = Pattern.compile("a 33-character-long pattern xxxxx"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2058 |
pattern = Pattern.compile("a thirty four character long regex"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2059 |
StringBuffer patternToBe = new StringBuffer(101); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2060 |
for (int i=0; i<100; i++) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2061 |
patternToBe.append((char)(97 + i%26)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2062 |
pattern = Pattern.compile(patternToBe.toString()); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2063 |
} catch (PatternSyntaxException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2064 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2065 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2066 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2067 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2068 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2069 |
Pattern pattern = Pattern.compile( |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2070 |
toSupplementaries("a 32-character-long pattern xxxx")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2071 |
pattern = Pattern.compile(toSupplementaries("a 33-character-long pattern xxxxx")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2072 |
pattern = Pattern.compile(toSupplementaries("a thirty four character long regex")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2073 |
StringBuffer patternToBe = new StringBuffer(101*2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2074 |
for (int i=0; i<100; i++) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2075 |
patternToBe.append(Character.toChars(Character.MIN_SUPPLEMENTARY_CODE_POINT |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2076 |
+ 97 + i%26)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2077 |
pattern = Pattern.compile(patternToBe.toString()); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2078 |
} catch (PatternSyntaxException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2079 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2080 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2081 |
report("LongPattern"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2082 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2083 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2084 |
private static void group0Test() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2085 |
Pattern pattern = Pattern.compile("(tes)ting"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2086 |
Matcher matcher = pattern.matcher("testing"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2087 |
check(matcher, "testing"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2088 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2089 |
matcher.reset("testing"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2090 |
if (matcher.lookingAt()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2091 |
if (!matcher.group(0).equals("testing")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2092 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2093 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2094 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2095 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2096 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2097 |
matcher.reset("testing"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2098 |
if (matcher.matches()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2099 |
if (!matcher.group(0).equals("testing")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2100 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2101 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2102 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2103 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2104 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2105 |
pattern = Pattern.compile("(tes)ting"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2106 |
matcher = pattern.matcher("testing"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2107 |
if (matcher.lookingAt()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2108 |
if (!matcher.group(0).equals("testing")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2109 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2110 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2111 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2112 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2113 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2114 |
pattern = Pattern.compile("^(tes)ting"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2115 |
matcher = pattern.matcher("testing"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2116 |
if (matcher.matches()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2117 |
if (!matcher.group(0).equals("testing")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2118 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2119 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2120 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2121 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2122 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2123 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2124 |
pattern = Pattern.compile(toSupplementaries("(tes)ting")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2125 |
matcher = pattern.matcher(toSupplementaries("testing")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2126 |
check(matcher, toSupplementaries("testing")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2127 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2128 |
matcher.reset(toSupplementaries("testing")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2129 |
if (matcher.lookingAt()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2130 |
if (!matcher.group(0).equals(toSupplementaries("testing"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2131 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2132 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2133 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2134 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2135 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2136 |
matcher.reset(toSupplementaries("testing")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2137 |
if (matcher.matches()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2138 |
if (!matcher.group(0).equals(toSupplementaries("testing"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2139 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2140 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2141 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2142 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2143 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2144 |
pattern = Pattern.compile(toSupplementaries("(tes)ting")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2145 |
matcher = pattern.matcher(toSupplementaries("testing")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2146 |
if (matcher.lookingAt()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2147 |
if (!matcher.group(0).equals(toSupplementaries("testing"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2148 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2149 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2150 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2151 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2152 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2153 |
pattern = Pattern.compile(toSupplementaries("^(tes)ting")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2154 |
matcher = pattern.matcher(toSupplementaries("testing")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2155 |
if (matcher.matches()) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2156 |
if (!matcher.group(0).equals(toSupplementaries("testing"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2157 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2158 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2159 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2160 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2161 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2162 |
report("Group0"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2163 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2164 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2165 |
private static void findIntTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2166 |
Pattern p = Pattern.compile("blah"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2167 |
Matcher m = p.matcher("zzzzblahzzzzzblah"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2168 |
boolean result = m.find(2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2169 |
if (!result) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2170 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2171 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2172 |
p = Pattern.compile("$"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2173 |
m = p.matcher("1234567890"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2174 |
result = m.find(10); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2175 |
if (!result) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2176 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2177 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2178 |
result = m.find(11); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2179 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2180 |
} catch (IndexOutOfBoundsException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2181 |
// correct result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2182 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2183 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2184 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2185 |
p = Pattern.compile(toSupplementaries("blah")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2186 |
m = p.matcher(toSupplementaries("zzzzblahzzzzzblah")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2187 |
result = m.find(2); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2188 |
if (!result) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2189 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2190 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2191 |
report("FindInt"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2192 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2193 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2194 |
private static void emptyPatternTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2195 |
Pattern p = Pattern.compile(""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2196 |
Matcher m = p.matcher("foo"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2197 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2198 |
// Should find empty pattern at beginning of input |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2199 |
boolean result = m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2200 |
if (result != true) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2201 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2202 |
if (m.start() != 0) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2203 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2204 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2205 |
// Should not match entire input if input is not empty |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2206 |
m.reset(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2207 |
result = m.matches(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2208 |
if (result == true) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2209 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2210 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2211 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2212 |
m.start(0); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2213 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2214 |
} catch (IllegalStateException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2215 |
// Correct result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2216 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2217 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2218 |
// Should match entire input if input is empty |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2219 |
m.reset(""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2220 |
result = m.matches(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2221 |
if (result != true) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2222 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2223 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2224 |
result = Pattern.matches("", ""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2225 |
if (result != true) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2226 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2227 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2228 |
result = Pattern.matches("", "foo"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2229 |
if (result == true) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2230 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2231 |
report("EmptyPattern"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2232 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2233 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2234 |
private static void charClassTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2235 |
Pattern pattern = Pattern.compile("blah[ab]]blech"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2236 |
check(pattern, "blahb]blech", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2237 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2238 |
pattern = Pattern.compile("[abc[def]]"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2239 |
check(pattern, "b", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2240 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2241 |
// Supplementary character tests |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2242 |
pattern = Pattern.compile(toSupplementaries("blah[ab]]blech")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2243 |
check(pattern, toSupplementaries("blahb]blech"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2244 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2245 |
pattern = Pattern.compile(toSupplementaries("[abc[def]]")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2246 |
check(pattern, toSupplementaries("b"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2247 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2248 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2249 |
// u00ff when UNICODE_CASE |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2250 |
pattern = Pattern.compile("[ab\u00ffcd]", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2251 |
Pattern.CASE_INSENSITIVE| |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2252 |
Pattern.UNICODE_CASE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2253 |
check(pattern, "ab\u00ffcd", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2254 |
check(pattern, "Ab\u0178Cd", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2255 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2256 |
// u00b5 when UNICODE_CASE |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2257 |
pattern = Pattern.compile("[ab\u00b5cd]", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2258 |
Pattern.CASE_INSENSITIVE| |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2259 |
Pattern.UNICODE_CASE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2260 |
check(pattern, "ab\u00b5cd", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2261 |
check(pattern, "Ab\u039cCd", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2262 |
} catch (Exception e) { failCount++; } |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2263 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2264 |
/* Special cases |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2265 |
(1)LatinSmallLetterLongS u+017f |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2266 |
(2)LatinSmallLetterDotlessI u+0131 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2267 |
(3)LatineCapitalLetterIWithDotAbove u+0130 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2268 |
(4)KelvinSign u+212a |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2269 |
(5)AngstromSign u+212b |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2270 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2271 |
int flags = Pattern.UNICODE_CASE | Pattern.CASE_INSENSITIVE; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2272 |
pattern = Pattern.compile("[sik\u00c5]+", flags); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2273 |
if (!pattern.matcher("\u017f\u0130\u0131\u212a\u212b").matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2274 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2275 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2276 |
report("CharClass"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2277 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2278 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2279 |
private static void caretTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2280 |
Pattern pattern = Pattern.compile("\\w*"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2281 |
Matcher matcher = pattern.matcher("a#bc#def##g"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2282 |
check(matcher, "a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2283 |
check(matcher, ""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2284 |
check(matcher, "bc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2285 |
check(matcher, ""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2286 |
check(matcher, "def"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2287 |
check(matcher, ""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2288 |
check(matcher, ""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2289 |
check(matcher, "g"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2290 |
check(matcher, ""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2291 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2292 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2293 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2294 |
pattern = Pattern.compile("^\\w*"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2295 |
matcher = pattern.matcher("a#bc#def##g"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2296 |
check(matcher, "a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2297 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2298 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2299 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2300 |
pattern = Pattern.compile("\\w"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2301 |
matcher = pattern.matcher("abc##x"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2302 |
check(matcher, "a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2303 |
check(matcher, "b"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2304 |
check(matcher, "c"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2305 |
check(matcher, "x"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2306 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2307 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2308 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2309 |
pattern = Pattern.compile("^\\w"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2310 |
matcher = pattern.matcher("abc##x"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2311 |
check(matcher, "a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2312 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2313 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2314 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2315 |
pattern = Pattern.compile("\\A\\p{Alpha}{3}"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2316 |
matcher = pattern.matcher("abcdef-ghi\njklmno"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2317 |
check(matcher, "abc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2318 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2319 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2320 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2321 |
pattern = Pattern.compile("^\\p{Alpha}{3}", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2322 |
matcher = pattern.matcher("abcdef-ghi\njklmno"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2323 |
check(matcher, "abc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2324 |
check(matcher, "jkl"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2325 |
if (matcher.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2326 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2327 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2328 |
pattern = Pattern.compile("^", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2329 |
matcher = pattern.matcher("this is some text"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2330 |
String result = matcher.replaceAll("X"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2331 |
if (!result.equals("Xthis is some text")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2332 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2333 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2334 |
pattern = Pattern.compile("^"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2335 |
matcher = pattern.matcher("this is some text"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2336 |
result = matcher.replaceAll("X"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2337 |
if (!result.equals("Xthis is some text")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2338 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2339 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2340 |
pattern = Pattern.compile("^", Pattern.MULTILINE | Pattern.UNIX_LINES); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2341 |
matcher = pattern.matcher("this is some text\n"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2342 |
result = matcher.replaceAll("X"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2343 |
if (!result.equals("Xthis is some text\n")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2344 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2345 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2346 |
report("Caret"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2347 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2348 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2349 |
private static void groupCaptureTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2350 |
// Independent group |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2351 |
Pattern pattern = Pattern.compile("x+(?>y+)z+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2352 |
Matcher matcher = pattern.matcher("xxxyyyzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2353 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2354 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2355 |
String blah = matcher.group(1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2356 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2357 |
} catch (IndexOutOfBoundsException ioobe) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2358 |
// Good result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2359 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2360 |
// Pure group |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2361 |
pattern = Pattern.compile("x+(?:y+)z+"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2362 |
matcher = pattern.matcher("xxxyyyzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2363 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2364 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2365 |
String blah = matcher.group(1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2366 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2367 |
} catch (IndexOutOfBoundsException ioobe) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2368 |
// Good result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2369 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2370 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2371 |
// Supplementary character tests |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2372 |
// Independent group |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2373 |
pattern = Pattern.compile(toSupplementaries("x+(?>y+)z+")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2374 |
matcher = pattern.matcher(toSupplementaries("xxxyyyzzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2375 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2376 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2377 |
String blah = matcher.group(1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2378 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2379 |
} catch (IndexOutOfBoundsException ioobe) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2380 |
// Good result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2381 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2382 |
// Pure group |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2383 |
pattern = Pattern.compile(toSupplementaries("x+(?:y+)z+")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2384 |
matcher = pattern.matcher(toSupplementaries("xxxyyyzzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2385 |
matcher.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2386 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2387 |
String blah = matcher.group(1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2388 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2389 |
} catch (IndexOutOfBoundsException ioobe) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2390 |
// Good result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2391 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2392 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2393 |
report("GroupCapture"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2394 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2395 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2396 |
private static void backRefTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2397 |
Pattern pattern = Pattern.compile("(a*)bc\\1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2398 |
check(pattern, "zzzaabcazzz", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2399 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2400 |
pattern = Pattern.compile("(a*)bc\\1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2401 |
check(pattern, "zzzaabcaazzz", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2402 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2403 |
pattern = Pattern.compile("(abc)(def)\\1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2404 |
check(pattern, "abcdefabc", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2405 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2406 |
pattern = Pattern.compile("(abc)(def)\\3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2407 |
check(pattern, "abcdefabc", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2408 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2409 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2410 |
for (int i = 1; i < 10; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2411 |
// Make sure backref 1-9 are always accepted |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2412 |
pattern = Pattern.compile("abcdef\\" + i); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2413 |
// and fail to match if the target group does not exit |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2414 |
check(pattern, "abcdef", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2415 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2416 |
} catch(PatternSyntaxException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2417 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2418 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2419 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2420 |
pattern = Pattern.compile("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\\11"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2421 |
check(pattern, "abcdefghija", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2422 |
check(pattern, "abcdefghija1", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2423 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2424 |
pattern = Pattern.compile("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2425 |
check(pattern, "abcdefghijkk", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2426 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2427 |
pattern = Pattern.compile("(a)bcdefghij\\11"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2428 |
check(pattern, "abcdefghija1", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2429 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2430 |
// Supplementary character tests |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2431 |
pattern = Pattern.compile(toSupplementaries("(a*)bc\\1")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2432 |
check(pattern, toSupplementaries("zzzaabcazzz"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2433 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2434 |
pattern = Pattern.compile(toSupplementaries("(a*)bc\\1")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2435 |
check(pattern, toSupplementaries("zzzaabcaazzz"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2436 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2437 |
pattern = Pattern.compile(toSupplementaries("(abc)(def)\\1")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2438 |
check(pattern, toSupplementaries("abcdefabc"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2439 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2440 |
pattern = Pattern.compile(toSupplementaries("(abc)(def)\\3")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2441 |
check(pattern, toSupplementaries("abcdefabc"), false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2442 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2443 |
pattern = Pattern.compile(toSupplementaries("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)\\11")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2444 |
check(pattern, toSupplementaries("abcdefghija"), false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2445 |
check(pattern, toSupplementaries("abcdefghija1"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2446 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2447 |
pattern = Pattern.compile(toSupplementaries("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(k)\\11")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2448 |
check(pattern, toSupplementaries("abcdefghijkk"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2449 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2450 |
report("BackRef"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2451 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2452 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2453 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2454 |
* Unicode Technical Report #18, section 2.6 End of Line |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2455 |
* There is no empty line to be matched in the sequence \u000D\u000A |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2456 |
* but there is an empty line in the sequence \u000A\u000D. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2457 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2458 |
private static void anchorTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2459 |
Pattern p = Pattern.compile("^.*$", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2460 |
Matcher m = p.matcher("blah1\r\nblah2"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2461 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2462 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2463 |
if (!m.group().equals("blah2")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2464 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2465 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2466 |
m.reset("blah1\n\rblah2"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2467 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2468 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2469 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2470 |
if (!m.group().equals("blah2")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2471 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2472 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2473 |
// Test behavior of $ with \r\n at end of input |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2474 |
p = Pattern.compile(".+$"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2475 |
m = p.matcher("blah1\r\n"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2476 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2477 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2478 |
if (!m.group().equals("blah1")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2479 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2480 |
if (m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2481 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2482 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2483 |
// Test behavior of $ with \r\n at end of input in multiline |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2484 |
p = Pattern.compile(".+$", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2485 |
m = p.matcher("blah1\r\n"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2486 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2487 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2488 |
if (m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2489 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2490 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2491 |
// Test for $ recognition of \u0085 for bug 4527731 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2492 |
p = Pattern.compile(".+$", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2493 |
m = p.matcher("blah1\u0085"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2494 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2495 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2496 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2497 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2498 |
p = Pattern.compile("^.*$", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2499 |
m = p.matcher(toSupplementaries("blah1\r\nblah2")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2500 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2501 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2502 |
if (!m.group().equals(toSupplementaries("blah2"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2503 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2504 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2505 |
m.reset(toSupplementaries("blah1\n\rblah2")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2506 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2507 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2508 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2509 |
if (!m.group().equals(toSupplementaries("blah2"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2510 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2511 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2512 |
// Test behavior of $ with \r\n at end of input |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2513 |
p = Pattern.compile(".+$"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2514 |
m = p.matcher(toSupplementaries("blah1\r\n")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2515 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2516 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2517 |
if (!m.group().equals(toSupplementaries("blah1"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2518 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2519 |
if (m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2520 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2521 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2522 |
// Test behavior of $ with \r\n at end of input in multiline |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2523 |
p = Pattern.compile(".+$", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2524 |
m = p.matcher(toSupplementaries("blah1\r\n")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2525 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2526 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2527 |
if (m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2528 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2529 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2530 |
// Test for $ recognition of \u0085 for bug 4527731 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2531 |
p = Pattern.compile(".+$", Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2532 |
m = p.matcher(toSupplementaries("blah1\u0085")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2533 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2534 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2535 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2536 |
report("Anchors"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2537 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2538 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2539 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2540 |
* A basic sanity test of Matcher.lookingAt(). |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2541 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2542 |
private static void lookingAtTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2543 |
Pattern p = Pattern.compile("(ab)(c*)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2544 |
Matcher m = p.matcher("abccczzzabcczzzabccc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2545 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2546 |
if (!m.lookingAt()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2547 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2548 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2549 |
if (!m.group().equals(m.group(0))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2550 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2551 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2552 |
m = p.matcher("zzzabccczzzabcczzzabccczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2553 |
if (m.lookingAt()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2554 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2555 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2556 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2557 |
p = Pattern.compile(toSupplementaries("(ab)(c*)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2558 |
m = p.matcher(toSupplementaries("abccczzzabcczzzabccc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2559 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2560 |
if (!m.lookingAt()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2561 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2562 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2563 |
if (!m.group().equals(m.group(0))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2564 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2565 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2566 |
m = p.matcher(toSupplementaries("zzzabccczzzabcczzzabccczzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2567 |
if (m.lookingAt()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2568 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2569 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2570 |
report("Looking At"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2571 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2572 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2573 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2574 |
* A basic sanity test of Matcher.matches(). |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2575 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2576 |
private static void matchesTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2577 |
// matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2578 |
Pattern p = Pattern.compile("ulb(c*)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2579 |
Matcher m = p.matcher("ulbcccccc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2580 |
if (!m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2581 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2582 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2583 |
// find() but not matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2584 |
m.reset("zzzulbcccccc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2585 |
if (m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2586 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2587 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2588 |
// lookingAt() but not matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2589 |
m.reset("ulbccccccdef"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2590 |
if (m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2591 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2592 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2593 |
// matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2594 |
p = Pattern.compile("a|ad"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2595 |
m = p.matcher("ad"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2596 |
if (!m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2597 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2598 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2599 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2600 |
// matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2601 |
p = Pattern.compile(toSupplementaries("ulb(c*)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2602 |
m = p.matcher(toSupplementaries("ulbcccccc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2603 |
if (!m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2604 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2605 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2606 |
// find() but not matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2607 |
m.reset(toSupplementaries("zzzulbcccccc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2608 |
if (m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2609 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2610 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2611 |
// lookingAt() but not matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2612 |
m.reset(toSupplementaries("ulbccccccdef")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2613 |
if (m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2614 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2615 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2616 |
// matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2617 |
p = Pattern.compile(toSupplementaries("a|ad")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2618 |
m = p.matcher(toSupplementaries("ad")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2619 |
if (!m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2620 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2621 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2622 |
report("Matches"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2623 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2624 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2625 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2626 |
* A basic sanity test of Pattern.matches(). |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2627 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2628 |
private static void patternMatchesTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2629 |
// matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2630 |
if (!Pattern.matches(toSupplementaries("ulb(c*)"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2631 |
toSupplementaries("ulbcccccc"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2632 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2633 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2634 |
// find() but not matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2635 |
if (Pattern.matches(toSupplementaries("ulb(c*)"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2636 |
toSupplementaries("zzzulbcccccc"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2637 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2638 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2639 |
// lookingAt() but not matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2640 |
if (Pattern.matches(toSupplementaries("ulb(c*)"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2641 |
toSupplementaries("ulbccccccdef"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2642 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2643 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2644 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2645 |
// matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2646 |
if (!Pattern.matches(toSupplementaries("ulb(c*)"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2647 |
toSupplementaries("ulbcccccc"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2648 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2649 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2650 |
// find() but not matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2651 |
if (Pattern.matches(toSupplementaries("ulb(c*)"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2652 |
toSupplementaries("zzzulbcccccc"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2653 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2654 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2655 |
// lookingAt() but not matches() |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2656 |
if (Pattern.matches(toSupplementaries("ulb(c*)"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2657 |
toSupplementaries("ulbccccccdef"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2658 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2659 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2660 |
report("Pattern Matches"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2661 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2662 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2663 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2664 |
* Canonical equivalence testing. Tests the ability of the engine |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2665 |
* to match sequences that are not explicitly specified in the |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2666 |
* pattern when they are considered equivalent by the Unicode Standard. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2667 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2668 |
private static void ceTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2669 |
// Decomposed char outside char classes |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2670 |
Pattern p = Pattern.compile("testa\u030a", Pattern.CANON_EQ); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2671 |
Matcher m = p.matcher("test\u00e5"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2672 |
if (!m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2673 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2674 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2675 |
m.reset("testa\u030a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2676 |
if (!m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2677 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2678 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2679 |
// Composed char outside char classes |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2680 |
p = Pattern.compile("test\u00e5", Pattern.CANON_EQ); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2681 |
m = p.matcher("test\u00e5"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2682 |
if (!m.matches()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2683 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2684 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2685 |
m.reset("testa\u030a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2686 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2687 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2688 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2689 |
// Decomposed char inside a char class |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2690 |
p = Pattern.compile("test[abca\u030a]", Pattern.CANON_EQ); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2691 |
m = p.matcher("test\u00e5"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2692 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2693 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2694 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2695 |
m.reset("testa\u030a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2696 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2697 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2698 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2699 |
// Composed char inside a char class |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2700 |
p = Pattern.compile("test[abc\u00e5def\u00e0]", Pattern.CANON_EQ); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2701 |
m = p.matcher("test\u00e5"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2702 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2703 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2704 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2705 |
m.reset("testa\u0300"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2706 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2707 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2708 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2709 |
m.reset("testa\u030a"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2710 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2711 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2712 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2713 |
// Marks that cannot legally change order and be equivalent |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2714 |
p = Pattern.compile("testa\u0308\u0300", Pattern.CANON_EQ); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2715 |
check(p, "testa\u0308\u0300", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2716 |
check(p, "testa\u0300\u0308", false); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2717 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2718 |
// Marks that can legally change order and be equivalent |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2719 |
p = Pattern.compile("testa\u0308\u0323", Pattern.CANON_EQ); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2720 |
check(p, "testa\u0308\u0323", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2721 |
check(p, "testa\u0323\u0308", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2722 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2723 |
// Test all equivalences of the sequence a\u0308\u0323\u0300 |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2724 |
p = Pattern.compile("testa\u0308\u0323\u0300", Pattern.CANON_EQ); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2725 |
check(p, "testa\u0308\u0323\u0300", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2726 |
check(p, "testa\u0323\u0308\u0300", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2727 |
check(p, "testa\u0308\u0300\u0323", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2728 |
check(p, "test\u00e4\u0323\u0300", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2729 |
check(p, "test\u00e4\u0300\u0323", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2730 |
|
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2731 |
Object[][] data = new Object[][] { |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2732 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2733 |
// JDK-4867170 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2734 |
{ "[\u1f80-\u1f82]", "ab\u1f80cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2735 |
{ "[\u1f80-\u1f82]", "ab\u1f81cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2736 |
{ "[\u1f80-\u1f82]", "ab\u1f82cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2737 |
{ "[\u1f80-\u1f82]", "ab\u03b1\u0314\u0345cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2738 |
{ "[\u1f80-\u1f82]", "ab\u03b1\u0345\u0314cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2739 |
{ "[\u1f80-\u1f82]", "ab\u1f01\u0345cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2740 |
{ "[\u1f80-\u1f82]", "ab\u1f00\u0345cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2741 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2742 |
{ "\\p{IsGreek}", "ab\u1f80cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2743 |
{ "\\p{IsGreek}", "ab\u1f81cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2744 |
{ "\\p{IsGreek}", "ab\u1f82cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2745 |
{ "\\p{IsGreek}", "ab\u03b1\u0314\u0345cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2746 |
{ "\\p{IsGreek}", "ab\u1f01\u0345cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2747 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2748 |
// backtracking, force to match "\u1f80", instead of \u1f82" |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2749 |
{ "ab\\p{IsGreek}\u0300cd", "ab\u03b1\u0313\u0345\u0300cd", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2750 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2751 |
{ "[\\p{IsGreek}]", "\u03b1\u0314\u0345", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2752 |
{ "\\p{IsGreek}", "\u03b1\u0314\u0345", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2753 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2754 |
{ "[^\u1f80-\u1f82]","\u1f81", "m", false }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2755 |
{ "[^\u1f80-\u1f82]","\u03b1\u0314\u0345", "m", false }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2756 |
{ "[^\u1f01\u0345]", "\u1f81", "f", false }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2757 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2758 |
{ "[^\u1f81]+", "\u1f80\u1f82", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2759 |
{ "[\u1f80]", "ab\u1f80cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2760 |
{ "\u1f80", "ab\u1f80cd", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2761 |
{ "\u1f00\u0345\u0300", "\u1f82", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2762 |
{ "\u1f80", "-\u1f00\u0345\u0300-", "f", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2763 |
{ "\u1f82", "\u1f00\u0345\u0300", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2764 |
{ "\u1f82", "\u1f80\u0300", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2765 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2766 |
// JDK-7080302 # compile failed |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2767 |
{ "a(\u0041\u0301\u0328)", "a\u0041\u0301\u0328", "m", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2768 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2769 |
// JDK-6728861, same cause as above one |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2770 |
{ "\u00e9\u00e9n", "e\u0301e\u0301n", "m", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2771 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2772 |
// JDK-6995635 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2773 |
{ "(\u00e9)", "e\u0301", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2774 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2775 |
// JDK-6736245 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2776 |
// intereting special case, nfc(u2add+u0338) -> u2add+u0338) NOT u2adc |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2777 |
{ "\u2ADC", "\u2ADC", "m", true}, // NFC |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2778 |
{ "\u2ADC", "\u2ADD\u0338", "m", true}, // NFD |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2779 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2780 |
// 4916384. |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2781 |
// Decomposed hangul (jamos) works inside clazz |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2782 |
{ "[\u1100\u1161]", "\u1100\u1161", "m", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2783 |
{ "[\u1100\u1161]", "\uac00", "m", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2784 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2785 |
{ "[\uac00]", "\u1100\u1161", "m", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2786 |
{ "[\uac00]", "\uac00", "m", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2787 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2788 |
// Decomposed hangul (jamos) |
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2789 |
{ "\u1100\u1161", "\u1100\u1161", "m", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2790 |
{ "\u1100\u1161", "\uac00", "m", true}, |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2791 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2792 |
// Composed hangul |
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2793 |
{ "\uac00", "\u1100\u1161", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2794 |
{ "\uac00", "\uac00", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2795 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2796 |
/* Need a NFDSlice to nfd the source to solve this issue |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2797 |
u+1d1c0 -> nfd: <u+1d1ba><u+1d165><u+1d16f> -> nfc: <u+1d1ba><u+1d165><u+1d16f> |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2798 |
u+1d1bc -> nfd: <u+1d1ba><u+1d165> -> nfc: <u+1d1ba><u+1d165> |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2799 |
<u+1d1bc><u+1d16f> -> nfd: <u+1d1ba><u+1d165><u+1d16f> -> nfc: <u+1d1ba><u+1d165><u+1d16f> |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2800 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2801 |
// Decomposed supplementary outside char classes |
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2802 |
// { "test\ud834\uddbc\ud834\udd6f", "test\ud834\uddc0", "m", true }, |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2803 |
// Composed supplementary outside char classes |
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2804 |
// { "test\ud834\uddc0", "test\ud834\uddbc\ud834\udd6f", "m", true }, |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2805 |
*/ |
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2806 |
{ "test\ud834\uddbc\ud834\udd6f", "test\ud834\uddbc\ud834\udd6f", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2807 |
{ "test\ud834\uddc0", "test\ud834\uddbc\ud834\udd6f", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2808 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2809 |
{ "test\ud834\uddc0", "test\ud834\uddc0", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2810 |
{ "test\ud834\uddbc\ud834\udd6f", "test\ud834\uddc0", "m", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2811 |
}; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2812 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2813 |
int failCount = 0; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2814 |
for (Object[] d : data) { |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2815 |
String pn = (String)d[0]; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2816 |
String tt = (String)d[1]; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2817 |
boolean isFind = "f".equals(((String)d[2])); |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2818 |
boolean expected = (boolean)d[3]; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2819 |
boolean ret = isFind ? Pattern.compile(pn, Pattern.CANON_EQ).matcher(tt).find() |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2820 |
: Pattern.compile(pn, Pattern.CANON_EQ).matcher(tt).matches(); |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2821 |
if (ret != expected) { |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2822 |
failCount++; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2823 |
continue; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2824 |
} |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
2825 |
} |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2826 |
report("Canonical Equivalence"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2827 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2828 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2829 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2830 |
* A basic sanity test of Matcher.replaceAll(). |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2831 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2832 |
private static void globalSubstitute() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2833 |
// Global substitution with a literal |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2834 |
Pattern p = Pattern.compile("(ab)(c*)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2835 |
Matcher m = p.matcher("abccczzzabcczzzabccc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2836 |
if (!m.replaceAll("test").equals("testzzztestzzztest")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2837 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2838 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2839 |
m.reset("zzzabccczzzabcczzzabccczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2840 |
if (!m.replaceAll("test").equals("zzztestzzztestzzztestzzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2841 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2842 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2843 |
// Global substitution with groups |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2844 |
m.reset("zzzabccczzzabcczzzabccczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2845 |
String result = m.replaceAll("$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2846 |
if (!result.equals("zzzabzzzabzzzabzzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2847 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2848 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2849 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2850 |
// Global substitution with a literal |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2851 |
p = Pattern.compile(toSupplementaries("(ab)(c*)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2852 |
m = p.matcher(toSupplementaries("abccczzzabcczzzabccc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2853 |
if (!m.replaceAll(toSupplementaries("test")). |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2854 |
equals(toSupplementaries("testzzztestzzztest"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2855 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2856 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2857 |
m.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2858 |
if (!m.replaceAll(toSupplementaries("test")). |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2859 |
equals(toSupplementaries("zzztestzzztestzzztestzzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2860 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2861 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2862 |
// Global substitution with groups |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2863 |
m.reset(toSupplementaries("zzzabccczzzabcczzzabccczzz")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2864 |
result = m.replaceAll("$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2865 |
if (!result.equals(toSupplementaries("zzzabzzzabzzzabzzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2866 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2867 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2868 |
report("Global Substitution"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2869 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2870 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2871 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2872 |
* Tests the usage of Matcher.appendReplacement() with literal |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2873 |
* and group substitutions. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2874 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2875 |
private static void stringbufferSubstitute() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2876 |
// SB substitution with literal |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2877 |
String blah = "zzzblahzzz"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2878 |
Pattern p = Pattern.compile("blah"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2879 |
Matcher m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2880 |
StringBuffer result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2881 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2882 |
m.appendReplacement(result, "blech"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2883 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2884 |
} catch (IllegalStateException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2885 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2886 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2887 |
m.appendReplacement(result, "blech"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2888 |
if (!result.toString().equals("zzzblech")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2889 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2890 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2891 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2892 |
if (!result.toString().equals("zzzblechzzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2893 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2894 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2895 |
// SB substitution with groups |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2896 |
blah = "zzzabcdzzz"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2897 |
p = Pattern.compile("(ab)(cd)*"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2898 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2899 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2900 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2901 |
m.appendReplacement(result, "$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2902 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2903 |
} catch (IllegalStateException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2904 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2905 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2906 |
m.appendReplacement(result, "$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2907 |
if (!result.toString().equals("zzzab")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2908 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2909 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2910 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2911 |
if (!result.toString().equals("zzzabzzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2912 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2913 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2914 |
// SB substitution with 3 groups |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2915 |
blah = "zzzabcdcdefzzz"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2916 |
p = Pattern.compile("(ab)(cd)*(ef)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2917 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2918 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2919 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2920 |
m.appendReplacement(result, "$1w$2w$3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2921 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2922 |
} catch (IllegalStateException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2923 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2924 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2925 |
m.appendReplacement(result, "$1w$2w$3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2926 |
if (!result.toString().equals("zzzabwcdwef")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2927 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2928 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2929 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2930 |
if (!result.toString().equals("zzzabwcdwefzzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2931 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2932 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2933 |
// SB substitution with groups and three matches |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2934 |
// skipping middle match |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2935 |
blah = "zzzabcdzzzabcddzzzabcdzzz"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2936 |
p = Pattern.compile("(ab)(cd*)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2937 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2938 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2939 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2940 |
m.appendReplacement(result, "$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2941 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2942 |
} catch (IllegalStateException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2943 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2944 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2945 |
m.appendReplacement(result, "$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2946 |
if (!result.toString().equals("zzzab")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2947 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2948 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2949 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2950 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2951 |
m.appendReplacement(result, "$2"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2952 |
if (!result.toString().equals("zzzabzzzabcddzzzcd")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2953 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2954 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2955 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2956 |
if (!result.toString().equals("zzzabzzzabcddzzzcdzzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2957 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2958 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2959 |
// Check to make sure escaped $ is ignored |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2960 |
blah = "zzzabcdcdefzzz"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2961 |
p = Pattern.compile("(ab)(cd)*(ef)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2962 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2963 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2964 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2965 |
m.appendReplacement(result, "$1w\\$2w$3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2966 |
if (!result.toString().equals("zzzabw$2wef")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2967 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2968 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2969 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2970 |
if (!result.toString().equals("zzzabw$2wefzzz")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2971 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2972 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2973 |
// Check to make sure a reference to nonexistent group causes error |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2974 |
blah = "zzzabcdcdefzzz"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2975 |
p = Pattern.compile("(ab)(cd)*(ef)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2976 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2977 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2978 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2979 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2980 |
m.appendReplacement(result, "$1w$5w$3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2981 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2982 |
} catch (IndexOutOfBoundsException ioobe) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2983 |
// Correct result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2984 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2985 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2986 |
// Check double digit group references |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2987 |
blah = "zzz123456789101112zzz"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2988 |
p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2989 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2990 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2991 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2992 |
m.appendReplacement(result, "$1w$11w$3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2993 |
if (!result.toString().equals("zzz1w11w3")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2994 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2995 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2996 |
// Check to make sure it backs off $15 to $1 if only three groups |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2997 |
blah = "zzzabcdcdefzzz"; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2998 |
p = Pattern.compile("(ab)(cd)*(ef)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
2999 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3000 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3001 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3002 |
m.appendReplacement(result, "$1w$15w$3"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3003 |
if (!result.toString().equals("zzzabwab5wef")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3004 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3005 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3006 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3007 |
// Supplementary character test |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3008 |
// SB substitution with literal |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3009 |
blah = toSupplementaries("zzzblahzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3010 |
p = Pattern.compile(toSupplementaries("blah")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3011 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3012 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3013 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3014 |
m.appendReplacement(result, toSupplementaries("blech")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3015 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3016 |
} catch (IllegalStateException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3017 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3018 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3019 |
m.appendReplacement(result, toSupplementaries("blech")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3020 |
if (!result.toString().equals(toSupplementaries("zzzblech"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3021 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3022 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3023 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3024 |
if (!result.toString().equals(toSupplementaries("zzzblechzzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3025 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3026 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3027 |
// SB substitution with groups |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3028 |
blah = toSupplementaries("zzzabcdzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3029 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3030 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3031 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3032 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3033 |
m.appendReplacement(result, "$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3034 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3035 |
} catch (IllegalStateException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3036 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3037 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3038 |
m.appendReplacement(result, "$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3039 |
if (!result.toString().equals(toSupplementaries("zzzab"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3040 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3041 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3042 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3043 |
if (!result.toString().equals(toSupplementaries("zzzabzzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3044 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3045 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3046 |
// SB substitution with 3 groups |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3047 |
blah = toSupplementaries("zzzabcdcdefzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3048 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3049 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3050 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3051 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3052 |
m.appendReplacement(result, toSupplementaries("$1w$2w$3")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3053 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3054 |
} catch (IllegalStateException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3055 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3056 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3057 |
m.appendReplacement(result, toSupplementaries("$1w$2w$3")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3058 |
if (!result.toString().equals(toSupplementaries("zzzabwcdwef"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3059 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3060 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3061 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3062 |
if (!result.toString().equals(toSupplementaries("zzzabwcdwefzzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3063 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3064 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3065 |
// SB substitution with groups and three matches |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3066 |
// skipping middle match |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3067 |
blah = toSupplementaries("zzzabcdzzzabcddzzzabcdzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3068 |
p = Pattern.compile(toSupplementaries("(ab)(cd*)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3069 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3070 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3071 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3072 |
m.appendReplacement(result, "$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3073 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3074 |
} catch (IllegalStateException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3075 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3076 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3077 |
m.appendReplacement(result, "$1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3078 |
if (!result.toString().equals(toSupplementaries("zzzab"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3079 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3080 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3081 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3082 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3083 |
m.appendReplacement(result, "$2"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3084 |
if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcd"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3085 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3086 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3087 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3088 |
if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcdzzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3089 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3090 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3091 |
// Check to make sure escaped $ is ignored |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3092 |
blah = toSupplementaries("zzzabcdcdefzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3093 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3094 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3095 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3096 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3097 |
m.appendReplacement(result, toSupplementaries("$1w\\$2w$3")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3098 |
if (!result.toString().equals(toSupplementaries("zzzabw$2wef"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3099 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3100 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3101 |
m.appendTail(result); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3102 |
if (!result.toString().equals(toSupplementaries("zzzabw$2wefzzz"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3103 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3104 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3105 |
// Check to make sure a reference to nonexistent group causes error |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3106 |
blah = toSupplementaries("zzzabcdcdefzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3107 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3108 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3109 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3110 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3111 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3112 |
m.appendReplacement(result, toSupplementaries("$1w$5w$3")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3113 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3114 |
} catch (IndexOutOfBoundsException ioobe) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3115 |
// Correct result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3116 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3117 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3118 |
// Check double digit group references |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3119 |
blah = toSupplementaries("zzz123456789101112zzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3120 |
p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3121 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3122 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3123 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3124 |
m.appendReplacement(result, toSupplementaries("$1w$11w$3")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3125 |
if (!result.toString().equals(toSupplementaries("zzz1w11w3"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3126 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3127 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3128 |
// Check to make sure it backs off $15 to $1 if only three groups |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3129 |
blah = toSupplementaries("zzzabcdcdefzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3130 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3131 |
m = p.matcher(blah); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3132 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3133 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3134 |
m.appendReplacement(result, toSupplementaries("$1w$15w$3")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3135 |
if (!result.toString().equals(toSupplementaries("zzzabwab5wef"))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3136 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3137 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3138 |
// Check nothing has been appended into the output buffer if |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3139 |
// the replacement string triggers IllegalArgumentException. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3140 |
p = Pattern.compile("(abc)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3141 |
m = p.matcher("abcd"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3142 |
result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3143 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3144 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3145 |
m.appendReplacement(result, ("xyz$g")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3146 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3147 |
} catch (IllegalArgumentException iae) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3148 |
if (result.length() != 0) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3149 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3150 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3151 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3152 |
report("SB Substitution"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3153 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3154 |
|
23734
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3155 |
/** |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3156 |
* Tests the usage of Matcher.appendReplacement() with literal |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3157 |
* and group substitutions. |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3158 |
*/ |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3159 |
private static void stringbuilderSubstitute() throws Exception { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3160 |
// SB substitution with literal |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3161 |
String blah = "zzzblahzzz"; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3162 |
Pattern p = Pattern.compile("blah"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3163 |
Matcher m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3164 |
StringBuilder result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3165 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3166 |
m.appendReplacement(result, "blech"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3167 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3168 |
} catch (IllegalStateException e) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3169 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3170 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3171 |
m.appendReplacement(result, "blech"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3172 |
if (!result.toString().equals("zzzblech")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3173 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3174 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3175 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3176 |
if (!result.toString().equals("zzzblechzzz")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3177 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3178 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3179 |
// SB substitution with groups |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3180 |
blah = "zzzabcdzzz"; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3181 |
p = Pattern.compile("(ab)(cd)*"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3182 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3183 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3184 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3185 |
m.appendReplacement(result, "$1"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3186 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3187 |
} catch (IllegalStateException e) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3188 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3189 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3190 |
m.appendReplacement(result, "$1"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3191 |
if (!result.toString().equals("zzzab")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3192 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3193 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3194 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3195 |
if (!result.toString().equals("zzzabzzz")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3196 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3197 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3198 |
// SB substitution with 3 groups |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3199 |
blah = "zzzabcdcdefzzz"; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3200 |
p = Pattern.compile("(ab)(cd)*(ef)"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3201 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3202 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3203 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3204 |
m.appendReplacement(result, "$1w$2w$3"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3205 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3206 |
} catch (IllegalStateException e) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3207 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3208 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3209 |
m.appendReplacement(result, "$1w$2w$3"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3210 |
if (!result.toString().equals("zzzabwcdwef")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3211 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3212 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3213 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3214 |
if (!result.toString().equals("zzzabwcdwefzzz")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3215 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3216 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3217 |
// SB substitution with groups and three matches |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3218 |
// skipping middle match |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3219 |
blah = "zzzabcdzzzabcddzzzabcdzzz"; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3220 |
p = Pattern.compile("(ab)(cd*)"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3221 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3222 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3223 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3224 |
m.appendReplacement(result, "$1"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3225 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3226 |
} catch (IllegalStateException e) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3227 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3228 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3229 |
m.appendReplacement(result, "$1"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3230 |
if (!result.toString().equals("zzzab")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3231 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3232 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3233 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3234 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3235 |
m.appendReplacement(result, "$2"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3236 |
if (!result.toString().equals("zzzabzzzabcddzzzcd")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3237 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3238 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3239 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3240 |
if (!result.toString().equals("zzzabzzzabcddzzzcdzzz")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3241 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3242 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3243 |
// Check to make sure escaped $ is ignored |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3244 |
blah = "zzzabcdcdefzzz"; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3245 |
p = Pattern.compile("(ab)(cd)*(ef)"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3246 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3247 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3248 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3249 |
m.appendReplacement(result, "$1w\\$2w$3"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3250 |
if (!result.toString().equals("zzzabw$2wef")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3251 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3252 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3253 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3254 |
if (!result.toString().equals("zzzabw$2wefzzz")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3255 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3256 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3257 |
// Check to make sure a reference to nonexistent group causes error |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3258 |
blah = "zzzabcdcdefzzz"; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3259 |
p = Pattern.compile("(ab)(cd)*(ef)"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3260 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3261 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3262 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3263 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3264 |
m.appendReplacement(result, "$1w$5w$3"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3265 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3266 |
} catch (IndexOutOfBoundsException ioobe) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3267 |
// Correct result |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3268 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3269 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3270 |
// Check double digit group references |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3271 |
blah = "zzz123456789101112zzz"; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3272 |
p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3273 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3274 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3275 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3276 |
m.appendReplacement(result, "$1w$11w$3"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3277 |
if (!result.toString().equals("zzz1w11w3")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3278 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3279 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3280 |
// Check to make sure it backs off $15 to $1 if only three groups |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3281 |
blah = "zzzabcdcdefzzz"; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3282 |
p = Pattern.compile("(ab)(cd)*(ef)"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3283 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3284 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3285 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3286 |
m.appendReplacement(result, "$1w$15w$3"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3287 |
if (!result.toString().equals("zzzabwab5wef")) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3288 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3289 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3290 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3291 |
// Supplementary character test |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3292 |
// SB substitution with literal |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3293 |
blah = toSupplementaries("zzzblahzzz"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3294 |
p = Pattern.compile(toSupplementaries("blah")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3295 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3296 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3297 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3298 |
m.appendReplacement(result, toSupplementaries("blech")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3299 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3300 |
} catch (IllegalStateException e) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3301 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3302 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3303 |
m.appendReplacement(result, toSupplementaries("blech")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3304 |
if (!result.toString().equals(toSupplementaries("zzzblech"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3305 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3306 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3307 |
if (!result.toString().equals(toSupplementaries("zzzblechzzz"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3308 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3309 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3310 |
// SB substitution with groups |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3311 |
blah = toSupplementaries("zzzabcdzzz"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3312 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3313 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3314 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3315 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3316 |
m.appendReplacement(result, "$1"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3317 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3318 |
} catch (IllegalStateException e) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3319 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3320 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3321 |
m.appendReplacement(result, "$1"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3322 |
if (!result.toString().equals(toSupplementaries("zzzab"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3323 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3324 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3325 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3326 |
if (!result.toString().equals(toSupplementaries("zzzabzzz"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3327 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3328 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3329 |
// SB substitution with 3 groups |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3330 |
blah = toSupplementaries("zzzabcdcdefzzz"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3331 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3332 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3333 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3334 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3335 |
m.appendReplacement(result, toSupplementaries("$1w$2w$3")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3336 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3337 |
} catch (IllegalStateException e) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3338 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3339 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3340 |
m.appendReplacement(result, toSupplementaries("$1w$2w$3")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3341 |
if (!result.toString().equals(toSupplementaries("zzzabwcdwef"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3342 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3343 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3344 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3345 |
if (!result.toString().equals(toSupplementaries("zzzabwcdwefzzz"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3346 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3347 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3348 |
// SB substitution with groups and three matches |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3349 |
// skipping middle match |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3350 |
blah = toSupplementaries("zzzabcdzzzabcddzzzabcdzzz"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3351 |
p = Pattern.compile(toSupplementaries("(ab)(cd*)")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3352 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3353 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3354 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3355 |
m.appendReplacement(result, "$1"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3356 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3357 |
} catch (IllegalStateException e) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3358 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3359 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3360 |
m.appendReplacement(result, "$1"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3361 |
if (!result.toString().equals(toSupplementaries("zzzab"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3362 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3363 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3364 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3365 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3366 |
m.appendReplacement(result, "$2"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3367 |
if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcd"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3368 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3369 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3370 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3371 |
if (!result.toString().equals(toSupplementaries("zzzabzzzabcddzzzcdzzz"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3372 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3373 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3374 |
// Check to make sure escaped $ is ignored |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3375 |
blah = toSupplementaries("zzzabcdcdefzzz"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3376 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3377 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3378 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3379 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3380 |
m.appendReplacement(result, toSupplementaries("$1w\\$2w$3")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3381 |
if (!result.toString().equals(toSupplementaries("zzzabw$2wef"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3382 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3383 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3384 |
m.appendTail(result); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3385 |
if (!result.toString().equals(toSupplementaries("zzzabw$2wefzzz"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3386 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3387 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3388 |
// Check to make sure a reference to nonexistent group causes error |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3389 |
blah = toSupplementaries("zzzabcdcdefzzz"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3390 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3391 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3392 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3393 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3394 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3395 |
m.appendReplacement(result, toSupplementaries("$1w$5w$3")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3396 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3397 |
} catch (IndexOutOfBoundsException ioobe) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3398 |
// Correct result |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3399 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3400 |
// Check double digit group references |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3401 |
blah = toSupplementaries("zzz123456789101112zzz"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3402 |
p = Pattern.compile("(1)(2)(3)(4)(5)(6)(7)(8)(9)(10)(11)"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3403 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3404 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3405 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3406 |
m.appendReplacement(result, toSupplementaries("$1w$11w$3")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3407 |
if (!result.toString().equals(toSupplementaries("zzz1w11w3"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3408 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3409 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3410 |
// Check to make sure it backs off $15 to $1 if only three groups |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3411 |
blah = toSupplementaries("zzzabcdcdefzzz"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3412 |
p = Pattern.compile(toSupplementaries("(ab)(cd)*(ef)")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3413 |
m = p.matcher(blah); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3414 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3415 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3416 |
m.appendReplacement(result, toSupplementaries("$1w$15w$3")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3417 |
if (!result.toString().equals(toSupplementaries("zzzabwab5wef"))) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3418 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3419 |
// Check nothing has been appended into the output buffer if |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3420 |
// the replacement string triggers IllegalArgumentException. |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3421 |
p = Pattern.compile("(abc)"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3422 |
m = p.matcher("abcd"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3423 |
result = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3424 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3425 |
try { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3426 |
m.appendReplacement(result, ("xyz$g")); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3427 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3428 |
} catch (IllegalArgumentException iae) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3429 |
if (result.length() != 0) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3430 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3431 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3432 |
report("SB Substitution 2"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3433 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3434 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3435 |
/* |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3436 |
* 5 groups of characters are created to make a substitution string. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3437 |
* A base string will be created including random lead chars, the |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3438 |
* substitution string, and random trailing chars. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3439 |
* A pattern containing the 5 groups is searched for and replaced with: |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3440 |
* random group + random string + random group. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3441 |
* The results are checked for correctness. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3442 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3443 |
private static void substitutionBasher() { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3444 |
for (int runs = 0; runs<1000; runs++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3445 |
// Create a base string to work in |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3446 |
int leadingChars = generator.nextInt(10); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3447 |
StringBuffer baseBuffer = new StringBuffer(100); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3448 |
String leadingString = getRandomAlphaString(leadingChars); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3449 |
baseBuffer.append(leadingString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3450 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3451 |
// Create 5 groups of random number of random chars |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3452 |
// Create the string to substitute |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3453 |
// Create the pattern string to search for |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3454 |
StringBuffer bufferToSub = new StringBuffer(25); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3455 |
StringBuffer bufferToPat = new StringBuffer(50); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3456 |
String[] groups = new String[5]; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3457 |
for(int i=0; i<5; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3458 |
int aGroupSize = generator.nextInt(5)+1; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3459 |
groups[i] = getRandomAlphaString(aGroupSize); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3460 |
bufferToSub.append(groups[i]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3461 |
bufferToPat.append('('); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3462 |
bufferToPat.append(groups[i]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3463 |
bufferToPat.append(')'); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3464 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3465 |
String stringToSub = bufferToSub.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3466 |
String pattern = bufferToPat.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3467 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3468 |
// Place sub string into working string at random index |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3469 |
baseBuffer.append(stringToSub); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3470 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3471 |
// Append random chars to end |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3472 |
int trailingChars = generator.nextInt(10); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3473 |
String trailingString = getRandomAlphaString(trailingChars); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3474 |
baseBuffer.append(trailingString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3475 |
String baseString = baseBuffer.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3476 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3477 |
// Create test pattern and matcher |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3478 |
Pattern p = Pattern.compile(pattern); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3479 |
Matcher m = p.matcher(baseString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3480 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3481 |
// Reject candidate if pattern happens to start early |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3482 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3483 |
if (m.start() < leadingChars) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3484 |
continue; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3485 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3486 |
// Reject candidate if more than one match |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3487 |
if (m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3488 |
continue; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3489 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3490 |
// Construct a replacement string with : |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3491 |
// random group + random string + random group |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3492 |
StringBuffer bufferToRep = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3493 |
int groupIndex1 = generator.nextInt(5); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3494 |
bufferToRep.append("$" + (groupIndex1 + 1)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3495 |
String randomMidString = getRandomAlphaString(5); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3496 |
bufferToRep.append(randomMidString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3497 |
int groupIndex2 = generator.nextInt(5); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3498 |
bufferToRep.append("$" + (groupIndex2 + 1)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3499 |
String replacement = bufferToRep.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3500 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3501 |
// Do the replacement |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3502 |
String result = m.replaceAll(replacement); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3503 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3504 |
// Construct expected result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3505 |
StringBuffer bufferToRes = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3506 |
bufferToRes.append(leadingString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3507 |
bufferToRes.append(groups[groupIndex1]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3508 |
bufferToRes.append(randomMidString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3509 |
bufferToRes.append(groups[groupIndex2]); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3510 |
bufferToRes.append(trailingString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3511 |
String expectedResult = bufferToRes.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3512 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3513 |
// Check results |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3514 |
if (!result.equals(expectedResult)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3515 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3516 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3517 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3518 |
report("Substitution Basher"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3519 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3520 |
|
23734
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3521 |
/* |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3522 |
* 5 groups of characters are created to make a substitution string. |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3523 |
* A base string will be created including random lead chars, the |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3524 |
* substitution string, and random trailing chars. |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3525 |
* A pattern containing the 5 groups is searched for and replaced with: |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3526 |
* random group + random string + random group. |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3527 |
* The results are checked for correctness. |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3528 |
*/ |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3529 |
private static void substitutionBasher2() { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3530 |
for (int runs = 0; runs<1000; runs++) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3531 |
// Create a base string to work in |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3532 |
int leadingChars = generator.nextInt(10); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3533 |
StringBuilder baseBuffer = new StringBuilder(100); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3534 |
String leadingString = getRandomAlphaString(leadingChars); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3535 |
baseBuffer.append(leadingString); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3536 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3537 |
// Create 5 groups of random number of random chars |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3538 |
// Create the string to substitute |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3539 |
// Create the pattern string to search for |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3540 |
StringBuilder bufferToSub = new StringBuilder(25); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3541 |
StringBuilder bufferToPat = new StringBuilder(50); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3542 |
String[] groups = new String[5]; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3543 |
for(int i=0; i<5; i++) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3544 |
int aGroupSize = generator.nextInt(5)+1; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3545 |
groups[i] = getRandomAlphaString(aGroupSize); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3546 |
bufferToSub.append(groups[i]); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3547 |
bufferToPat.append('('); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3548 |
bufferToPat.append(groups[i]); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3549 |
bufferToPat.append(')'); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3550 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3551 |
String stringToSub = bufferToSub.toString(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3552 |
String pattern = bufferToPat.toString(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3553 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3554 |
// Place sub string into working string at random index |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3555 |
baseBuffer.append(stringToSub); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3556 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3557 |
// Append random chars to end |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3558 |
int trailingChars = generator.nextInt(10); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3559 |
String trailingString = getRandomAlphaString(trailingChars); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3560 |
baseBuffer.append(trailingString); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3561 |
String baseString = baseBuffer.toString(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3562 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3563 |
// Create test pattern and matcher |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3564 |
Pattern p = Pattern.compile(pattern); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3565 |
Matcher m = p.matcher(baseString); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3566 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3567 |
// Reject candidate if pattern happens to start early |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3568 |
m.find(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3569 |
if (m.start() < leadingChars) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3570 |
continue; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3571 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3572 |
// Reject candidate if more than one match |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3573 |
if (m.find()) |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3574 |
continue; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3575 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3576 |
// Construct a replacement string with : |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3577 |
// random group + random string + random group |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3578 |
StringBuilder bufferToRep = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3579 |
int groupIndex1 = generator.nextInt(5); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3580 |
bufferToRep.append("$" + (groupIndex1 + 1)); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3581 |
String randomMidString = getRandomAlphaString(5); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3582 |
bufferToRep.append(randomMidString); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3583 |
int groupIndex2 = generator.nextInt(5); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3584 |
bufferToRep.append("$" + (groupIndex2 + 1)); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3585 |
String replacement = bufferToRep.toString(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3586 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3587 |
// Do the replacement |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3588 |
String result = m.replaceAll(replacement); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3589 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3590 |
// Construct expected result |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3591 |
StringBuilder bufferToRes = new StringBuilder(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3592 |
bufferToRes.append(leadingString); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3593 |
bufferToRes.append(groups[groupIndex1]); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3594 |
bufferToRes.append(randomMidString); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3595 |
bufferToRes.append(groups[groupIndex2]); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3596 |
bufferToRes.append(trailingString); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3597 |
String expectedResult = bufferToRes.toString(); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3598 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3599 |
// Check results |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3600 |
if (!result.equals(expectedResult)) { |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3601 |
failCount++; |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3602 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3603 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3604 |
|
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3605 |
report("Substitution Basher 2"); |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3606 |
} |
439905b27f94
8039124: j.u.regex.Matcher.appendReplace/Tail() should support StringBuilder variant
sherman
parents:
22997
diff
changeset
|
3607 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3608 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3609 |
* Checks the handling of some escape sequences that the Pattern |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3610 |
* class should process instead of the java compiler. These are |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3611 |
* not in the file because the escapes should be be processed |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3612 |
* by the Pattern class when the regex is compiled. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3613 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3614 |
private static void escapes() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3615 |
Pattern p = Pattern.compile("\\043"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3616 |
Matcher m = p.matcher("#"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3617 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3618 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3619 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3620 |
p = Pattern.compile("\\x23"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3621 |
m = p.matcher("#"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3622 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3623 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3624 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3625 |
p = Pattern.compile("\\u0023"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3626 |
m = p.matcher("#"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3627 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3628 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3629 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3630 |
report("Escape sequences"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3631 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3632 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3633 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3634 |
* Checks the handling of blank input situations. These |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3635 |
* tests are incompatible with my test file format. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3636 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3637 |
private static void blankInput() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3638 |
Pattern p = Pattern.compile("abc", Pattern.CASE_INSENSITIVE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3639 |
Matcher m = p.matcher(""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3640 |
if (m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3641 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3642 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3643 |
p = Pattern.compile("a*", Pattern.CASE_INSENSITIVE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3644 |
m = p.matcher(""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3645 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3646 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3647 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3648 |
p = Pattern.compile("abc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3649 |
m = p.matcher(""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3650 |
if (m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3651 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3652 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3653 |
p = Pattern.compile("a*"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3654 |
m = p.matcher(""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3655 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3656 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3657 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3658 |
report("Blank input"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3659 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3660 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3661 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3662 |
* Tests the Boyer-Moore pattern matching of a character sequence |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3663 |
* on randomly generated patterns. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3664 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3665 |
private static void bm() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3666 |
doBnM('a'); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3667 |
report("Boyer Moore (ASCII)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3668 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3669 |
doBnM(Character.MIN_SUPPLEMENTARY_CODE_POINT - 10); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3670 |
report("Boyer Moore (Supplementary)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3671 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3672 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3673 |
private static void doBnM(int baseCharacter) throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3674 |
int achar=0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3675 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3676 |
for (int i=0; i<100; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3677 |
// Create a short pattern to search for |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3678 |
int patternLength = generator.nextInt(7) + 4; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3679 |
StringBuffer patternBuffer = new StringBuffer(patternLength); |
31645
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3680 |
String pattern; |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3681 |
retry: for (;;) { |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3682 |
for (int x=0; x<patternLength; x++) { |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3683 |
int ch = baseCharacter + generator.nextInt(26); |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3684 |
if (Character.isSupplementaryCodePoint(ch)) { |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3685 |
patternBuffer.append(Character.toChars(ch)); |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3686 |
} else { |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3687 |
patternBuffer.append((char)ch); |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3688 |
} |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3689 |
} |
31645
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3690 |
pattern = patternBuffer.toString(); |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3691 |
|
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3692 |
// Avoid patterns that start and end with the same substring |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3693 |
// See JDK-6854417 |
34436
33c20335507c
8143854: java/util/regex/RegExTest.java.RegExTest failed
sherman
parents:
31645
diff
changeset
|
3694 |
for (int x=1; x < pattern.length(); x++) { |
31645
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3695 |
if (pattern.startsWith(pattern.substring(x))) |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3696 |
continue retry; |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3697 |
} |
26db68d6758c
6854417: TESTBUG: java/util/regex/RegExTest.java fails intermittently
igerasim
parents:
30436
diff
changeset
|
3698 |
break; |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3699 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3700 |
Pattern p = Pattern.compile(pattern); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3701 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3702 |
// Create a buffer with random ASCII chars that does |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3703 |
// not match the sample |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3704 |
String toSearch = null; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3705 |
StringBuffer s = null; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3706 |
Matcher m = p.matcher(""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3707 |
do { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3708 |
s = new StringBuffer(100); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3709 |
for (int x=0; x<100; x++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3710 |
int ch = baseCharacter + generator.nextInt(26); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3711 |
if (Character.isSupplementaryCodePoint(ch)) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3712 |
s.append(Character.toChars(ch)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3713 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3714 |
s.append((char)ch); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3715 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3716 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3717 |
toSearch = s.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3718 |
m.reset(toSearch); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3719 |
} while (m.find()); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3720 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3721 |
// Insert the pattern at a random spot |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3722 |
int insertIndex = generator.nextInt(99); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3723 |
if (Character.isLowSurrogate(s.charAt(insertIndex))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3724 |
insertIndex++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3725 |
s = s.insert(insertIndex, pattern); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3726 |
toSearch = s.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3727 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3728 |
// Make sure that the pattern is found |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3729 |
m.reset(toSearch); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3730 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3731 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3732 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3733 |
// Make sure that the match text is the pattern |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3734 |
if (!m.group().equals(pattern)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3735 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3736 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3737 |
// Make sure match occured at insertion point |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3738 |
if (m.start() != insertIndex) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3739 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3740 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3741 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3742 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3743 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3744 |
* Tests the matching of slices on randomly generated patterns. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3745 |
* The Boyer-Moore optimization is not done on these patterns |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3746 |
* because it uses unicode case folding. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3747 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3748 |
private static void slice() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3749 |
doSlice(Character.MAX_VALUE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3750 |
report("Slice"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3751 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3752 |
doSlice(Character.MAX_CODE_POINT); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3753 |
report("Slice (Supplementary)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3754 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3755 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3756 |
private static void doSlice(int maxCharacter) throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3757 |
Random generator = new Random(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3758 |
int achar=0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3759 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3760 |
for (int i=0; i<100; i++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3761 |
// Create a short pattern to search for |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3762 |
int patternLength = generator.nextInt(7) + 4; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3763 |
StringBuffer patternBuffer = new StringBuffer(patternLength); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3764 |
for (int x=0; x<patternLength; x++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3765 |
int randomChar = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3766 |
while (!Character.isLetterOrDigit(randomChar)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3767 |
randomChar = generator.nextInt(maxCharacter); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3768 |
if (Character.isSupplementaryCodePoint(randomChar)) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3769 |
patternBuffer.append(Character.toChars(randomChar)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3770 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3771 |
patternBuffer.append((char) randomChar); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3772 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3773 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3774 |
String pattern = patternBuffer.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3775 |
Pattern p = Pattern.compile(pattern, Pattern.UNICODE_CASE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3776 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3777 |
// Create a buffer with random chars that does not match the sample |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3778 |
String toSearch = null; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3779 |
StringBuffer s = null; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3780 |
Matcher m = p.matcher(""); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3781 |
do { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3782 |
s = new StringBuffer(100); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3783 |
for (int x=0; x<100; x++) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3784 |
int randomChar = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3785 |
while (!Character.isLetterOrDigit(randomChar)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3786 |
randomChar = generator.nextInt(maxCharacter); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3787 |
if (Character.isSupplementaryCodePoint(randomChar)) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3788 |
s.append(Character.toChars(randomChar)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3789 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3790 |
s.append((char) randomChar); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3791 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3792 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3793 |
toSearch = s.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3794 |
m.reset(toSearch); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3795 |
} while (m.find()); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3796 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3797 |
// Insert the pattern at a random spot |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3798 |
int insertIndex = generator.nextInt(99); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3799 |
if (Character.isLowSurrogate(s.charAt(insertIndex))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3800 |
insertIndex++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3801 |
s = s.insert(insertIndex, pattern); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3802 |
toSearch = s.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3803 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3804 |
// Make sure that the pattern is found |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3805 |
m.reset(toSearch); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3806 |
if (!m.find()) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3807 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3808 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3809 |
// Make sure that the match text is the pattern |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3810 |
if (!m.group().equals(pattern)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3811 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3812 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3813 |
// Make sure match occured at insertion point |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3814 |
if (m.start() != insertIndex) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3815 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3816 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3817 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3818 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3819 |
private static void explainFailure(String pattern, String data, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3820 |
String expected, String actual) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3821 |
System.err.println("----------------------------------------"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3822 |
System.err.println("Pattern = "+pattern); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3823 |
System.err.println("Data = "+data); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3824 |
System.err.println("Expected = " + expected); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3825 |
System.err.println("Actual = " + actual); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3826 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3827 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3828 |
private static void explainFailure(String pattern, String data, |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3829 |
Throwable t) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3830 |
System.err.println("----------------------------------------"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3831 |
System.err.println("Pattern = "+pattern); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3832 |
System.err.println("Data = "+data); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3833 |
t.printStackTrace(System.err); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3834 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3835 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3836 |
// Testing examples from a file |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3837 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3838 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3839 |
* Goes through the file "TestCases.txt" and creates many patterns |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3840 |
* described in the file, matching the patterns against input lines in |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3841 |
* the file, and comparing the results against the correct results |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3842 |
* also found in the file. The file format is described in comments |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3843 |
* at the head of the file. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3844 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3845 |
private static void processFile(String fileName) throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3846 |
File testCases = new File(System.getProperty("test.src", "."), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3847 |
fileName); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3848 |
FileInputStream in = new FileInputStream(testCases); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3849 |
BufferedReader r = new BufferedReader(new InputStreamReader(in)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3850 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3851 |
// Process next test case. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3852 |
String aLine; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3853 |
while((aLine = r.readLine()) != null) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3854 |
// Read a line for pattern |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3855 |
String patternString = grabLine(r); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3856 |
Pattern p = null; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3857 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3858 |
p = compileTestPattern(patternString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3859 |
} catch (PatternSyntaxException e) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3860 |
String dataString = grabLine(r); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3861 |
String expectedResult = grabLine(r); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3862 |
if (expectedResult.startsWith("error")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3863 |
continue; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3864 |
explainFailure(patternString, dataString, e); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3865 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3866 |
continue; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3867 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3868 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3869 |
// Read a line for input string |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3870 |
String dataString = grabLine(r); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3871 |
Matcher m = p.matcher(dataString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3872 |
StringBuffer result = new StringBuffer(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3873 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3874 |
// Check for IllegalStateExceptions before a match |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3875 |
failCount += preMatchInvariants(m); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3876 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3877 |
boolean found = m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3878 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3879 |
if (found) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3880 |
failCount += postTrueMatchInvariants(m); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3881 |
else |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3882 |
failCount += postFalseMatchInvariants(m); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3883 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3884 |
if (found) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3885 |
result.append("true "); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3886 |
result.append(m.group(0) + " "); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3887 |
} else { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3888 |
result.append("false "); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3889 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3890 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3891 |
result.append(m.groupCount()); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3892 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3893 |
if (found) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3894 |
for (int i=1; i<m.groupCount()+1; i++) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3895 |
if (m.group(i) != null) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3896 |
result.append(" " +m.group(i)); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3897 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3898 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3899 |
// Read a line for the expected result |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3900 |
String expectedResult = grabLine(r); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3901 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3902 |
if (!result.toString().equals(expectedResult)) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3903 |
explainFailure(patternString, dataString, expectedResult, result.toString()); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3904 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3905 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3906 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3907 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3908 |
report(fileName); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3909 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3910 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3911 |
private static int preMatchInvariants(Matcher m) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3912 |
int failCount = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3913 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3914 |
m.start(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3915 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3916 |
} catch (IllegalStateException ise) {} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3917 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3918 |
m.end(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3919 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3920 |
} catch (IllegalStateException ise) {} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3921 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3922 |
m.group(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3923 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3924 |
} catch (IllegalStateException ise) {} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3925 |
return failCount; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3926 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3927 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3928 |
private static int postFalseMatchInvariants(Matcher m) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3929 |
int failCount = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3930 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3931 |
m.group(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3932 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3933 |
} catch (IllegalStateException ise) {} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3934 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3935 |
m.start(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3936 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3937 |
} catch (IllegalStateException ise) {} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3938 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3939 |
m.end(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3940 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3941 |
} catch (IllegalStateException ise) {} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3942 |
return failCount; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3943 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3944 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3945 |
private static int postTrueMatchInvariants(Matcher m) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3946 |
int failCount = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3947 |
//assert(m.start() = m.start(0); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3948 |
if (m.start() != m.start(0)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3949 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3950 |
//assert(m.end() = m.end(0); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3951 |
if (m.start() != m.start(0)) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3952 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3953 |
//assert(m.group() = m.group(0); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3954 |
if (!m.group().equals(m.group(0))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3955 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3956 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3957 |
m.group(50); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3958 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3959 |
} catch (IndexOutOfBoundsException ise) {} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3960 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3961 |
return failCount; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3962 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3963 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3964 |
private static Pattern compileTestPattern(String patternString) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3965 |
if (!patternString.startsWith("'")) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3966 |
return Pattern.compile(patternString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3967 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3968 |
int break1 = patternString.lastIndexOf("'"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3969 |
String flagString = patternString.substring( |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3970 |
break1+1, patternString.length()); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3971 |
patternString = patternString.substring(1, break1); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3972 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3973 |
if (flagString.equals("i")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3974 |
return Pattern.compile(patternString, Pattern.CASE_INSENSITIVE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3975 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3976 |
if (flagString.equals("m")) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3977 |
return Pattern.compile(patternString, Pattern.MULTILINE); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3978 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3979 |
return Pattern.compile(patternString); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3980 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3981 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3982 |
/** |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3983 |
* Reads a line from the input file. Keeps reading lines until a non |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3984 |
* empty non comment line is read. If the line contains a \n then |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3985 |
* these two characters are replaced by a newline char. If a \\uxxxx |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3986 |
* sequence is read then the sequence is replaced by the unicode char. |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3987 |
*/ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3988 |
private static String grabLine(BufferedReader r) throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3989 |
int index = 0; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3990 |
String line = r.readLine(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3991 |
while (line.startsWith("//") || line.length() < 1) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3992 |
line = r.readLine(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3993 |
while ((index = line.indexOf("\\n")) != -1) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3994 |
StringBuffer temp = new StringBuffer(line); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3995 |
temp.replace(index, index+2, "\n"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3996 |
line = temp.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3997 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3998 |
while ((index = line.indexOf("\\u")) != -1) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
3999 |
StringBuffer temp = new StringBuffer(line); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4000 |
String value = temp.substring(index+2, index+6); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4001 |
char aChar = (char)Integer.parseInt(value, 16); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4002 |
String unicodeChar = "" + aChar; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4003 |
temp.replace(index, index+6, unicodeChar); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4004 |
line = temp.toString(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4005 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4006 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4007 |
return line; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4008 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4009 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4010 |
private static void check(Pattern p, String s, String g, String expected) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4011 |
Matcher m = p.matcher(s); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4012 |
m.find(); |
17434
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4013 |
if (!m.group(g).equals(expected) || |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4014 |
s.charAt(m.start(g)) != expected.charAt(0) || |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4015 |
s.charAt(m.end(g) - 1) != expected.charAt(expected.length() - 1)) |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4016 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4017 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4018 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4019 |
private static void checkReplaceFirst(String p, String s, String r, String expected) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4020 |
{ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4021 |
if (!expected.equals(Pattern.compile(p) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4022 |
.matcher(s) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4023 |
.replaceFirst(r))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4024 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4025 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4026 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4027 |
private static void checkReplaceAll(String p, String s, String r, String expected) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4028 |
{ |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4029 |
if (!expected.equals(Pattern.compile(p) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4030 |
.matcher(s) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4031 |
.replaceAll(r))) |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4032 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4033 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4034 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4035 |
private static void checkExpectedFail(String p) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4036 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4037 |
Pattern.compile(p); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4038 |
} catch (PatternSyntaxException pse) { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4039 |
//pse.printStackTrace(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4040 |
return; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4041 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4042 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4043 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4044 |
|
17434
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4045 |
private static void checkExpectedIAE(Matcher m, String g) { |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4046 |
m.find(); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4047 |
try { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4048 |
m.group(g); |
17434
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4049 |
} catch (IllegalArgumentException x) { |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4050 |
//iae.printStackTrace(); |
17434
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4051 |
try { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4052 |
m.start(g); |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4053 |
} catch (IllegalArgumentException xx) { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4054 |
try { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4055 |
m.start(g); |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4056 |
} catch (IllegalArgumentException xxx) { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4057 |
return; |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4058 |
} |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4059 |
} |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4060 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4061 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4062 |
} |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4063 |
|
17434
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4064 |
private static void checkExpectedNPE(Matcher m) { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4065 |
m.find(); |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4066 |
try { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4067 |
m.group(null); |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4068 |
} catch (NullPointerException x) { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4069 |
try { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4070 |
m.start(null); |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4071 |
} catch (NullPointerException xx) { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4072 |
try { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4073 |
m.end(null); |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4074 |
} catch (NullPointerException xxx) { |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4075 |
return; |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4076 |
} |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4077 |
} |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4078 |
} |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4079 |
failCount++; |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4080 |
} |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4081 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4082 |
private static void namedGroupCaptureTest() throws Exception { |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4083 |
check(Pattern.compile("x+(?<gname>y+)z+"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4084 |
"xxxyyyzzz", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4085 |
"gname", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4086 |
"yyy"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4087 |
|
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4088 |
check(Pattern.compile("x+(?<gname8>y+)z+"), |
2290
3a3bde061968
6817475: named-capturing group name started with digit causes PSE exception
sherman
parents:
2070
diff
changeset
|
4089 |
"xxxyyyzzz", |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4090 |
"gname8", |
2290
3a3bde061968
6817475: named-capturing group name started with digit causes PSE exception
sherman
parents:
2070
diff
changeset
|
4091 |
"yyy"); |
3a3bde061968
6817475: named-capturing group name started with digit causes PSE exception
sherman
parents:
2070
diff
changeset
|
4092 |
|
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4093 |
//backref |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4094 |
Pattern pattern = Pattern.compile("(a*)bc\\1"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4095 |
check(pattern, "zzzaabcazzz", true); // found "abca" |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4096 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4097 |
check(Pattern.compile("(?<gname>a*)bc\\k<gname>"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4098 |
"zzzaabcaazzz", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4099 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4100 |
check(Pattern.compile("(?<gname>abc)(def)\\k<gname>"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4101 |
"abcdefabc", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4102 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4103 |
check(Pattern.compile("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)(?<gname>k)\\k<gname>"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4104 |
"abcdefghijkk", true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4105 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4106 |
// Supplementary character tests |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4107 |
check(Pattern.compile("(?<gname>" + toSupplementaries("a*)bc") + "\\k<gname>"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4108 |
toSupplementaries("zzzaabcazzz"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4109 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4110 |
check(Pattern.compile("(?<gname>" + toSupplementaries("a*)bc") + "\\k<gname>"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4111 |
toSupplementaries("zzzaabcaazzz"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4112 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4113 |
check(Pattern.compile("(?<gname>" + toSupplementaries("abc)(def)") + "\\k<gname>"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4114 |
toSupplementaries("abcdefabc"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4115 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4116 |
check(Pattern.compile(toSupplementaries("(a)(b)(c)(d)(e)(f)(g)(h)(i)(j)") + |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4117 |
"(?<gname>" + |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4118 |
toSupplementaries("k)") + "\\k<gname>"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4119 |
toSupplementaries("abcdefghijkk"), true); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4120 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4121 |
check(Pattern.compile("x+(?<gname>y+)z+\\k<gname>"), |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4122 |
"xxxyyyzzzyyy", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4123 |
"gname", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4124 |
"yyy"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4125 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4126 |
//replaceFirst/All |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4127 |
checkReplaceFirst("(?<gn>ab)(c*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4128 |
"abccczzzabcczzzabccc", |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4129 |
"${gn}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4130 |
"abzzzabcczzzabccc"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4131 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4132 |
checkReplaceAll("(?<gn>ab)(c*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4133 |
"abccczzzabcczzzabccc", |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4134 |
"${gn}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4135 |
"abzzzabzzzab"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4136 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4137 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4138 |
checkReplaceFirst("(?<gn>ab)(c*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4139 |
"zzzabccczzzabcczzzabccczzz", |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4140 |
"${gn}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4141 |
"zzzabzzzabcczzzabccczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4142 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4143 |
checkReplaceAll("(?<gn>ab)(c*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4144 |
"zzzabccczzzabcczzzabccczzz", |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4145 |
"${gn}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4146 |
"zzzabzzzabzzzabzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4147 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4148 |
checkReplaceFirst("(?<gn1>ab)(?<gn2>c*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4149 |
"zzzabccczzzabcczzzabccczzz", |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4150 |
"${gn2}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4151 |
"zzzccczzzabcczzzabccczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4152 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4153 |
checkReplaceAll("(?<gn1>ab)(?<gn2>c*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4154 |
"zzzabccczzzabcczzzabccczzz", |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4155 |
"${gn2}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4156 |
"zzzccczzzcczzzccczzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4157 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4158 |
//toSupplementaries("(ab)(c*)")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4159 |
checkReplaceFirst("(?<gn1>" + toSupplementaries("ab") + |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4160 |
")(?<gn2>" + toSupplementaries("c") + "*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4161 |
toSupplementaries("abccczzzabcczzzabccc"), |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4162 |
"${gn1}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4163 |
toSupplementaries("abzzzabcczzzabccc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4164 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4165 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4166 |
checkReplaceAll("(?<gn1>" + toSupplementaries("ab") + |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4167 |
")(?<gn2>" + toSupplementaries("c") + "*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4168 |
toSupplementaries("abccczzzabcczzzabccc"), |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4169 |
"${gn1}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4170 |
toSupplementaries("abzzzabzzzab")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4171 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4172 |
checkReplaceFirst("(?<gn1>" + toSupplementaries("ab") + |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4173 |
")(?<gn2>" + toSupplementaries("c") + "*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4174 |
toSupplementaries("abccczzzabcczzzabccc"), |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4175 |
"${gn2}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4176 |
toSupplementaries("ccczzzabcczzzabccc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4177 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4178 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4179 |
checkReplaceAll("(?<gn1>" + toSupplementaries("ab") + |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4180 |
")(?<gn2>" + toSupplementaries("c") + "*)", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4181 |
toSupplementaries("abccczzzabcczzzabccc"), |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4182 |
"${gn2}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4183 |
toSupplementaries("ccczzzcczzzccc")); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4184 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4185 |
checkReplaceFirst("(?<dog>Dog)AndCat", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4186 |
"zzzDogAndCatzzzDogAndCatzzz", |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4187 |
"${dog}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4188 |
"zzzDogzzzDogAndCatzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4189 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4190 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4191 |
checkReplaceAll("(?<dog>Dog)AndCat", |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4192 |
"zzzDogAndCatzzzDogAndCatzzz", |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4193 |
"${dog}", |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4194 |
"zzzDogzzzDogzzz"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4195 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4196 |
// backref in Matcher & String |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4197 |
if (!"abcdefghij".replaceFirst("cd(?<gn>ef)gh", "${gn}").equals("abefij") || |
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4198 |
!"abbbcbdbefgh".replaceAll("(?<gn>[a-e])b", "${gn}").equals("abcdefgh")) |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4199 |
failCount++; |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4200 |
|
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4201 |
// negative |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4202 |
checkExpectedFail("(?<groupnamehasnoascii.in>abc)(def)"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4203 |
checkExpectedFail("(?<groupnamehasnoascii_in>abc)(def)"); |
4161
679d00486dc6
6878475: Better syntax for the named capture group in regex
sherman
parents:
2290
diff
changeset
|
4204 |
checkExpectedFail("(?<6groupnamestartswithdigit>abc)(def)"); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4205 |
checkExpectedFail("(?<gname>abc)(def)\\k<gnameX>"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4206 |
checkExpectedFail("(?<gname>abc)(?<gname>def)\\k<gnameX>"); |
17434
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4207 |
checkExpectedIAE(Pattern.compile("(?<gname>abc)(def)").matcher("abcdef"), |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4208 |
"gnameX"); |
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4209 |
checkExpectedNPE(Pattern.compile("(?<gname>abc)(def)").matcher("abcdef")); |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4210 |
report("NamedGroupCapture"); |
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
4211 |
} |
4820
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4212 |
|
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4213 |
// This is for bug 6919132 |
4820
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4214 |
private static void nonBmpClassComplementTest() throws Exception { |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4215 |
Pattern p = Pattern.compile("\\P{Lu}"); |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4216 |
Matcher m = p.matcher(new String(new int[] {0x1d400}, 0, 1)); |
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4217 |
|
4820
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4218 |
if (m.find() && m.start() == 1) |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4219 |
failCount++; |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4220 |
|
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4221 |
// from a unicode category |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4222 |
p = Pattern.compile("\\P{Lu}"); |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4223 |
m = p.matcher(new String(new int[] {0x1d400}, 0, 1)); |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4224 |
if (m.find()) |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4225 |
failCount++; |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4226 |
if (!m.hitEnd()) |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4227 |
failCount++; |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4228 |
|
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4229 |
// block |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4230 |
p = Pattern.compile("\\P{InMathematicalAlphanumericSymbols}"); |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4231 |
m = p.matcher(new String(new int[] {0x1d400}, 0, 1)); |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4232 |
if (m.find() && m.start() == 1) |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4233 |
failCount++; |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4234 |
|
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4235 |
p = Pattern.compile("\\P{sc=GRANTHA}"); |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4236 |
m = p.matcher(new String(new int[] {0x11350}, 0, 1)); |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4237 |
if (m.find() && m.start() == 1) |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4238 |
failCount++; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4239 |
|
4820
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4240 |
report("NonBmpClassComplement"); |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4241 |
} |
e32f5d2ba062
6919132: Regex \P{Lu} selects half of a surrogate pari
sherman
parents:
4161
diff
changeset
|
4242 |
|
5610
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4243 |
private static void unicodePropertiesTest() throws Exception { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4244 |
// different forms |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4245 |
if (!Pattern.compile("\\p{IsLu}").matcher("A").matches() || |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4246 |
!Pattern.compile("\\p{Lu}").matcher("A").matches() || |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4247 |
!Pattern.compile("\\p{gc=Lu}").matcher("A").matches() || |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4248 |
!Pattern.compile("\\p{general_category=Lu}").matcher("A").matches() || |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4249 |
!Pattern.compile("\\p{IsLatin}").matcher("B").matches() || |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4250 |
!Pattern.compile("\\p{sc=Latin}").matcher("B").matches() || |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4251 |
!Pattern.compile("\\p{script=Latin}").matcher("B").matches() || |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4252 |
!Pattern.compile("\\p{InBasicLatin}").matcher("c").matches() || |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4253 |
!Pattern.compile("\\p{blk=BasicLatin}").matcher("c").matches() || |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4254 |
!Pattern.compile("\\p{block=BasicLatin}").matcher("c").matches()) |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4255 |
failCount++; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4256 |
|
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4257 |
Matcher common = Pattern.compile("\\p{script=Common}").matcher(""); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4258 |
Matcher unknown = Pattern.compile("\\p{IsUnknown}").matcher(""); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4259 |
Matcher lastSM = common; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4260 |
Character.UnicodeScript lastScript = Character.UnicodeScript.of(0); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4261 |
|
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4262 |
Matcher latin = Pattern.compile("\\p{block=basic_latin}").matcher(""); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4263 |
Matcher greek = Pattern.compile("\\p{InGreek}").matcher(""); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4264 |
Matcher lastBM = latin; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4265 |
Character.UnicodeBlock lastBlock = Character.UnicodeBlock.of(0); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4266 |
|
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4267 |
for (int cp = 1; cp < Character.MAX_CODE_POINT; cp++) { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4268 |
if (cp >= 0x30000 && (cp & 0x70) == 0){ |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4269 |
continue; // only pick couple code points, they are the same |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4270 |
} |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4271 |
|
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4272 |
// Unicode Script |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4273 |
Character.UnicodeScript script = Character.UnicodeScript.of(cp); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4274 |
Matcher m; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4275 |
String str = new String(Character.toChars(cp)); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4276 |
if (script == lastScript) { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4277 |
m = lastSM; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4278 |
m.reset(str); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4279 |
} else { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4280 |
m = Pattern.compile("\\p{Is" + script.name() + "}").matcher(str); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4281 |
} |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4282 |
if (!m.matches()) { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4283 |
failCount++; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4284 |
} |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4285 |
Matcher other = (script == Character.UnicodeScript.COMMON)? unknown : common; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4286 |
other.reset(str); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4287 |
if (other.matches()) { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4288 |
failCount++; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4289 |
} |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4290 |
lastSM = m; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4291 |
lastScript = script; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4292 |
|
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4293 |
// Unicode Block |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4294 |
Character.UnicodeBlock block = Character.UnicodeBlock.of(cp); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4295 |
if (block == null) { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4296 |
//System.out.printf("Not a Block: cp=%x%n", cp); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4297 |
continue; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4298 |
} |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4299 |
if (block == lastBlock) { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4300 |
m = lastBM; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4301 |
m.reset(str); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4302 |
} else { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4303 |
m = Pattern.compile("\\p{block=" + block.toString() + "}").matcher(str); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4304 |
} |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4305 |
if (!m.matches()) { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4306 |
failCount++; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4307 |
} |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4308 |
other = (block == Character.UnicodeBlock.BASIC_LATIN)? greek : latin; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4309 |
other.reset(str); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4310 |
if (other.matches()) { |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4311 |
failCount++; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4312 |
} |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4313 |
lastBM = m; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4314 |
lastBlock = block; |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4315 |
} |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4316 |
report("unicodeProperties"); |
fd2427610c7f
6945564: Unicode script support in Character class
sherman
parents:
5295
diff
changeset
|
4317 |
} |
8173
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4318 |
|
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4319 |
private static void unicodeHexNotationTest() throws Exception { |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4320 |
|
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4321 |
// negative |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4322 |
checkExpectedFail("\\x{-23}"); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4323 |
checkExpectedFail("\\x{110000}"); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4324 |
checkExpectedFail("\\x{}"); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4325 |
checkExpectedFail("\\x{AB[ef]"); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4326 |
|
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4327 |
// codepoint |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4328 |
check("^\\x{1033c}$", "\uD800\uDF3C", true); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4329 |
check("^\\xF0\\x90\\x8C\\xBC$", "\uD800\uDF3C", false); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4330 |
check("^\\x{D800}\\x{DF3c}+$", "\uD800\uDF3C", false); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4331 |
check("^\\xF0\\x90\\x8C\\xBC$", "\uD800\uDF3C", false); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4332 |
|
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4333 |
// in class |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4334 |
check("^[\\x{D800}\\x{DF3c}]+$", "\uD800\uDF3C", false); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4335 |
check("^[\\xF0\\x90\\x8C\\xBC]+$", "\uD800\uDF3C", false); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4336 |
check("^[\\x{D800}\\x{DF3C}]+$", "\uD800\uDF3C", false); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4337 |
check("^[\\x{DF3C}\\x{D800}]+$", "\uD800\uDF3C", false); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4338 |
check("^[\\x{D800}\\x{DF3C}]+$", "\uDF3C\uD800", true); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4339 |
check("^[\\x{DF3C}\\x{D800}]+$", "\uDF3C\uD800", true); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4340 |
|
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4341 |
for (int cp = 0; cp <= 0x10FFFF; cp++) { |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4342 |
String s = "A" + new String(Character.toChars(cp)) + "B"; |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4343 |
String hexUTF16 = (cp <= 0xFFFF)? String.format("\\u%04x", cp) |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4344 |
: String.format("\\u%04x\\u%04x", |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4345 |
(int) Character.toChars(cp)[0], |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4346 |
(int) Character.toChars(cp)[1]); |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4347 |
String hexCodePoint = "\\x{" + Integer.toHexString(cp) + "}"; |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4348 |
if (!Pattern.matches("A" + hexUTF16 + "B", s)) |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4349 |
failCount++; |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4350 |
if (!Pattern.matches("A[" + hexUTF16 + "]B", s)) |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4351 |
failCount++; |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4352 |
if (!Pattern.matches("A" + hexCodePoint + "B", s)) |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4353 |
failCount++; |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4354 |
if (!Pattern.matches("A[" + hexCodePoint + "]B", s)) |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4355 |
failCount++; |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4356 |
} |
a3a39b98e05a
7014645: Support perl style Unicode hex notation \x{...}
sherman
parents:
7668
diff
changeset
|
4357 |
report("unicodeHexNotation"); |
9536
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4358 |
} |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4359 |
|
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4360 |
private static void unicodeClassesTest() throws Exception { |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4361 |
|
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4362 |
Matcher lower = Pattern.compile("\\p{Lower}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4363 |
Matcher upper = Pattern.compile("\\p{Upper}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4364 |
Matcher ASCII = Pattern.compile("\\p{ASCII}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4365 |
Matcher alpha = Pattern.compile("\\p{Alpha}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4366 |
Matcher digit = Pattern.compile("\\p{Digit}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4367 |
Matcher alnum = Pattern.compile("\\p{Alnum}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4368 |
Matcher punct = Pattern.compile("\\p{Punct}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4369 |
Matcher graph = Pattern.compile("\\p{Graph}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4370 |
Matcher print = Pattern.compile("\\p{Print}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4371 |
Matcher blank = Pattern.compile("\\p{Blank}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4372 |
Matcher cntrl = Pattern.compile("\\p{Cntrl}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4373 |
Matcher xdigit = Pattern.compile("\\p{XDigit}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4374 |
Matcher space = Pattern.compile("\\p{Space}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4375 |
Matcher bound = Pattern.compile("\\b").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4376 |
Matcher word = Pattern.compile("\\w++").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4377 |
// UNICODE_CHARACTER_CLASS |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4378 |
Matcher lowerU = Pattern.compile("\\p{Lower}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4379 |
Matcher upperU = Pattern.compile("\\p{Upper}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4380 |
Matcher ASCIIU = Pattern.compile("\\p{ASCII}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4381 |
Matcher alphaU = Pattern.compile("\\p{Alpha}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4382 |
Matcher digitU = Pattern.compile("\\p{Digit}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4383 |
Matcher alnumU = Pattern.compile("\\p{Alnum}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4384 |
Matcher punctU = Pattern.compile("\\p{Punct}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4385 |
Matcher graphU = Pattern.compile("\\p{Graph}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4386 |
Matcher printU = Pattern.compile("\\p{Print}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4387 |
Matcher blankU = Pattern.compile("\\p{Blank}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4388 |
Matcher cntrlU = Pattern.compile("\\p{Cntrl}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4389 |
Matcher xdigitU = Pattern.compile("\\p{XDigit}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4390 |
Matcher spaceU = Pattern.compile("\\p{Space}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4391 |
Matcher boundU = Pattern.compile("\\b", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4392 |
Matcher wordU = Pattern.compile("\\w", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4393 |
// embedded flag (?U) |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4394 |
Matcher lowerEU = Pattern.compile("(?U)\\p{Lower}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4395 |
Matcher graphEU = Pattern.compile("(?U)\\p{Graph}", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4396 |
Matcher wordEU = Pattern.compile("(?U)\\w", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4397 |
|
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4398 |
Matcher bwb = Pattern.compile("\\b\\w\\b").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4399 |
Matcher bwbU = Pattern.compile("\\b\\w++\\b", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4400 |
Matcher bwbEU = Pattern.compile("(?U)\\b\\w++\\b", Pattern.UNICODE_CHARACTER_CLASS).matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4401 |
// properties |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4402 |
Matcher lowerP = Pattern.compile("\\p{IsLowerCase}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4403 |
Matcher upperP = Pattern.compile("\\p{IsUpperCase}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4404 |
Matcher titleP = Pattern.compile("\\p{IsTitleCase}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4405 |
Matcher letterP = Pattern.compile("\\p{IsLetter}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4406 |
Matcher alphaP = Pattern.compile("\\p{IsAlphabetic}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4407 |
Matcher ideogP = Pattern.compile("\\p{IsIdeographic}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4408 |
Matcher cntrlP = Pattern.compile("\\p{IsControl}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4409 |
Matcher spaceP = Pattern.compile("\\p{IsWhiteSpace}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4410 |
Matcher definedP = Pattern.compile("\\p{IsAssigned}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4411 |
Matcher nonCCPP = Pattern.compile("\\p{IsNoncharacterCodePoint}").matcher(""); |
17434
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4412 |
Matcher joinCrtl = Pattern.compile("\\p{IsJoinControl}").matcher(""); |
9536
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4413 |
// javaMethod |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4414 |
Matcher lowerJ = Pattern.compile("\\p{javaLowerCase}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4415 |
Matcher upperJ = Pattern.compile("\\p{javaUpperCase}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4416 |
Matcher alphaJ = Pattern.compile("\\p{javaAlphabetic}").matcher(""); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4417 |
Matcher ideogJ = Pattern.compile("\\p{javaIdeographic}").matcher(""); |
38450
516990ff3a4c
8143282: \p{Cn} unassigned code points should be included in \p{C}
sherman
parents:
37882
diff
changeset
|
4418 |
// GC/C |
516990ff3a4c
8143282: \p{Cn} unassigned code points should be included in \p{C}
sherman
parents:
37882
diff
changeset
|
4419 |
Matcher gcC = Pattern.compile("\\p{C}").matcher(""); |
9536
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4420 |
|
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4421 |
for (int cp = 1; cp < 0x30000; cp++) { |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4422 |
String str = new String(Character.toChars(cp)); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4423 |
int type = Character.getType(cp); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4424 |
if (// lower |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4425 |
POSIX_ASCII.isLower(cp) != lower.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4426 |
Character.isLowerCase(cp) != lowerU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4427 |
Character.isLowerCase(cp) != lowerP.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4428 |
Character.isLowerCase(cp) != lowerEU.reset(str).matches()|| |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4429 |
Character.isLowerCase(cp) != lowerJ.reset(str).matches()|| |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4430 |
// upper |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4431 |
POSIX_ASCII.isUpper(cp) != upper.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4432 |
POSIX_Unicode.isUpper(cp) != upperU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4433 |
Character.isUpperCase(cp) != upperP.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4434 |
Character.isUpperCase(cp) != upperJ.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4435 |
// alpha |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4436 |
POSIX_ASCII.isAlpha(cp) != alpha.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4437 |
POSIX_Unicode.isAlpha(cp) != alphaU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4438 |
Character.isAlphabetic(cp)!= alphaP.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4439 |
Character.isAlphabetic(cp)!= alphaJ.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4440 |
// digit |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4441 |
POSIX_ASCII.isDigit(cp) != digit.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4442 |
Character.isDigit(cp) != digitU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4443 |
// alnum |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4444 |
POSIX_ASCII.isAlnum(cp) != alnum.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4445 |
POSIX_Unicode.isAlnum(cp) != alnumU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4446 |
// punct |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4447 |
POSIX_ASCII.isPunct(cp) != punct.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4448 |
POSIX_Unicode.isPunct(cp) != punctU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4449 |
// graph |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4450 |
POSIX_ASCII.isGraph(cp) != graph.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4451 |
POSIX_Unicode.isGraph(cp) != graphU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4452 |
POSIX_Unicode.isGraph(cp) != graphEU.reset(str).matches()|| |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4453 |
// blank |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4454 |
POSIX_ASCII.isType(cp, POSIX_ASCII.BLANK) |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4455 |
!= blank.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4456 |
POSIX_Unicode.isBlank(cp) != blankU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4457 |
|
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4458 |
POSIX_ASCII.isPrint(cp) != print.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4459 |
POSIX_Unicode.isPrint(cp) != printU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4460 |
// cntrl |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4461 |
POSIX_ASCII.isCntrl(cp) != cntrl.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4462 |
POSIX_Unicode.isCntrl(cp) != cntrlU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4463 |
(Character.CONTROL == type) != cntrlP.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4464 |
// hexdigit |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4465 |
POSIX_ASCII.isHexDigit(cp) != xdigit.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4466 |
POSIX_Unicode.isHexDigit(cp) != xdigitU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4467 |
// space |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4468 |
POSIX_ASCII.isSpace(cp) != space.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4469 |
POSIX_Unicode.isSpace(cp) != spaceU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4470 |
POSIX_Unicode.isSpace(cp) != spaceP.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4471 |
// word |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4472 |
POSIX_ASCII.isWord(cp) != word.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4473 |
POSIX_Unicode.isWord(cp) != wordU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4474 |
POSIX_Unicode.isWord(cp) != wordEU.reset(str).matches()|| |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4475 |
// bwordb |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4476 |
POSIX_ASCII.isWord(cp) != bwb.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4477 |
POSIX_Unicode.isWord(cp) != bwbU.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4478 |
// properties |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4479 |
Character.isTitleCase(cp) != titleP.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4480 |
Character.isLetter(cp) != letterP.reset(str).matches()|| |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4481 |
Character.isIdeographic(cp) != ideogP.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4482 |
Character.isIdeographic(cp) != ideogJ.reset(str).matches() || |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4483 |
(Character.UNASSIGNED == type) == definedP.reset(str).matches() || |
17434
4a04d7127e80
8013252: Regex Matcher .start and .end should be accessible by group name
sherman
parents:
17183
diff
changeset
|
4484 |
POSIX_Unicode.isNoncharacterCodePoint(cp) != nonCCPP.reset(str).matches() || |
38450
516990ff3a4c
8143282: \p{Cn} unassigned code points should be included in \p{C}
sherman
parents:
37882
diff
changeset
|
4485 |
POSIX_Unicode.isJoinControl(cp) != joinCrtl.reset(str).matches() || |
516990ff3a4c
8143282: \p{Cn} unassigned code points should be included in \p{C}
sherman
parents:
37882
diff
changeset
|
4486 |
// gc_C |
516990ff3a4c
8143282: \p{Cn} unassigned code points should be included in \p{C}
sherman
parents:
37882
diff
changeset
|
4487 |
(Character.CONTROL == type || Character.FORMAT == type || |
516990ff3a4c
8143282: \p{Cn} unassigned code points should be included in \p{C}
sherman
parents:
37882
diff
changeset
|
4488 |
Character.PRIVATE_USE == type || Character.SURROGATE == type || |
516990ff3a4c
8143282: \p{Cn} unassigned code points should be included in \p{C}
sherman
parents:
37882
diff
changeset
|
4489 |
Character.UNASSIGNED == type) |
516990ff3a4c
8143282: \p{Cn} unassigned code points should be included in \p{C}
sherman
parents:
37882
diff
changeset
|
4490 |
!= gcC.reset(str).matches()) { |
9536
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4491 |
failCount++; |
38450
516990ff3a4c
8143282: \p{Cn} unassigned code points should be included in \p{C}
sherman
parents:
37882
diff
changeset
|
4492 |
} |
9536
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4493 |
} |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4494 |
|
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4495 |
// bounds/word align |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4496 |
twoFindIndexes(" \u0180sherman\u0400 ", bound, 1, 10); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4497 |
if (!bwbU.reset("\u0180sherman\u0400").matches()) |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4498 |
failCount++; |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4499 |
twoFindIndexes(" \u0180sh\u0345erman\u0400 ", bound, 1, 11); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4500 |
if (!bwbU.reset("\u0180sh\u0345erman\u0400").matches()) |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4501 |
failCount++; |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4502 |
twoFindIndexes(" \u0724\u0739\u0724 ", bound, 1, 4); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4503 |
if (!bwbU.reset("\u0724\u0739\u0724").matches()) |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4504 |
failCount++; |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4505 |
if (!bwbEU.reset("\u0724\u0739\u0724").matches()) |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4506 |
failCount++; |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4507 |
report("unicodePredefinedClasses"); |
648c9add2a74
7039066: j.u.rgex does not match TR18 RL1.4 Simple Word Boundaries and RL1.2 Properties
sherman
parents:
9035
diff
changeset
|
4508 |
} |
12675
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4509 |
|
35783
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4510 |
private static void unicodeCharacterNameTest() throws Exception { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4511 |
|
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4512 |
for (int cp = 0; cp < Character.MAX_CODE_POINT; cp++) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4513 |
if (!Character.isValidCodePoint(cp) || |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4514 |
Character.getType(cp) == Character.UNASSIGNED) |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4515 |
continue; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4516 |
String str = new String(Character.toChars(cp)); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4517 |
// single |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4518 |
String p = "\\N{" + Character.getName(cp) + "}"; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4519 |
if (!Pattern.compile(p).matcher(str).matches()) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4520 |
failCount++; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4521 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4522 |
// class[c] |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4523 |
p = "[\\N{" + Character.getName(cp) + "}]"; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4524 |
if (!Pattern.compile(p).matcher(str).matches()) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4525 |
failCount++; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4526 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4527 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4528 |
|
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4529 |
// range |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4530 |
for (int i = 0; i < 10; i++) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4531 |
int start = generator.nextInt(20); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4532 |
int end = start + generator.nextInt(200); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4533 |
String p = "[\\N{" + Character.getName(start) + "}-\\N{" + Character.getName(end) + "}]"; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4534 |
String str; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4535 |
for (int cp = start; cp < end; cp++) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4536 |
str = new String(Character.toChars(cp)); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4537 |
if (!Pattern.compile(p).matcher(str).matches()) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4538 |
failCount++; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4539 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4540 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4541 |
str = new String(Character.toChars(end + 10)); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4542 |
if (Pattern.compile(p).matcher(str).matches()) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4543 |
failCount++; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4544 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4545 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4546 |
|
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4547 |
// slice |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4548 |
for (int i = 0; i < 10; i++) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4549 |
int n = generator.nextInt(256); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4550 |
int[] buf = new int[n]; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4551 |
StringBuffer sb = new StringBuffer(1024); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4552 |
for (int j = 0; j < n; j++) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4553 |
int cp = generator.nextInt(1000); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4554 |
if (!Character.isValidCodePoint(cp) || |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4555 |
Character.getType(cp) == Character.UNASSIGNED) |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4556 |
cp = 0x4e00; // just use 4e00 |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4557 |
sb.append("\\N{" + Character.getName(cp) + "}"); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4558 |
buf[j] = cp; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4559 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4560 |
String p = sb.toString(); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4561 |
String str = new String(buf, 0, buf.length); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4562 |
if (!Pattern.compile(p).matcher(str).matches()) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4563 |
failCount++; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4564 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4565 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4566 |
report("unicodeCharacterName"); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4567 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4568 |
|
12675
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4569 |
private static void horizontalAndVerticalWSTest() throws Exception { |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4570 |
String hws = new String (new char[] { |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4571 |
0x09, 0x20, 0xa0, 0x1680, 0x180e, |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4572 |
0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4573 |
0x2006, 0x2007, 0x2008, 0x2009, 0x200a, |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4574 |
0x202f, 0x205f, 0x3000 }); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4575 |
String vws = new String (new char[] { |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4576 |
0x0a, 0x0b, 0x0c, 0x0d, 0x85, 0x2028, 0x2029 }); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4577 |
if (!Pattern.compile("\\h+").matcher(hws).matches() || |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4578 |
!Pattern.compile("[\\h]+").matcher(hws).matches()) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4579 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4580 |
if (Pattern.compile("\\H").matcher(hws).find() || |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4581 |
Pattern.compile("[\\H]").matcher(hws).find()) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4582 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4583 |
if (!Pattern.compile("\\v+").matcher(vws).matches() || |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4584 |
!Pattern.compile("[\\v]+").matcher(vws).matches()) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4585 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4586 |
if (Pattern.compile("\\V").matcher(vws).find() || |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4587 |
Pattern.compile("[\\V]").matcher(vws).find()) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4588 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4589 |
String prefix = "abcd"; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4590 |
String suffix = "efgh"; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4591 |
String ng = "A"; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4592 |
for (int i = 0; i < hws.length(); i++) { |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4593 |
String c = String.valueOf(hws.charAt(i)); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4594 |
Matcher m = Pattern.compile("\\h").matcher(prefix + c + suffix); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4595 |
if (!m.find() || !c.equals(m.group())) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4596 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4597 |
m = Pattern.compile("[\\h]").matcher(prefix + c + suffix); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4598 |
if (!m.find() || !c.equals(m.group())) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4599 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4600 |
|
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4601 |
m = Pattern.compile("\\H").matcher(hws.substring(0, i) + ng + hws.substring(i)); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4602 |
if (!m.find() || !ng.equals(m.group())) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4603 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4604 |
m = Pattern.compile("[\\H]").matcher(hws.substring(0, i) + ng + hws.substring(i)); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4605 |
if (!m.find() || !ng.equals(m.group())) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4606 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4607 |
} |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4608 |
for (int i = 0; i < vws.length(); i++) { |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4609 |
String c = String.valueOf(vws.charAt(i)); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4610 |
Matcher m = Pattern.compile("\\v").matcher(prefix + c + suffix); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4611 |
if (!m.find() || !c.equals(m.group())) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4612 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4613 |
m = Pattern.compile("[\\v]").matcher(prefix + c + suffix); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4614 |
if (!m.find() || !c.equals(m.group())) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4615 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4616 |
|
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4617 |
m = Pattern.compile("\\V").matcher(vws.substring(0, i) + ng + vws.substring(i)); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4618 |
if (!m.find() || !ng.equals(m.group())) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4619 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4620 |
m = Pattern.compile("[\\V]").matcher(vws.substring(0, i) + ng + vws.substring(i)); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4621 |
if (!m.find() || !ng.equals(m.group())) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4622 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4623 |
} |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4624 |
// \v in range is interpreted as 0x0B. This is the undocumented behavior |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4625 |
if (!Pattern.compile("[\\v-\\v]").matcher(String.valueOf((char)0x0B)).matches()) |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4626 |
failCount++; |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4627 |
report("horizontalAndVerticalWSTest"); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4628 |
} |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4629 |
|
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4630 |
private static void linebreakTest() throws Exception { |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4631 |
String linebreaks = new String (new char[] { |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4632 |
0x0A, 0x0B, 0x0C, 0x0D, 0x85, 0x2028, 0x2029 }); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4633 |
String crnl = "\r\n"; |
44122
65a14579a2ae
8176029: Linebreak matcher is not equivalent to the pattern as stated in javadoc
sherman
parents:
38777
diff
changeset
|
4634 |
if (!(Pattern.compile("\\R+").matcher(linebreaks).matches() && |
65a14579a2ae
8176029: Linebreak matcher is not equivalent to the pattern as stated in javadoc
sherman
parents:
38777
diff
changeset
|
4635 |
Pattern.compile("\\R").matcher(crnl).matches() && |
65a14579a2ae
8176029: Linebreak matcher is not equivalent to the pattern as stated in javadoc
sherman
parents:
38777
diff
changeset
|
4636 |
Pattern.compile("\\Rabc").matcher(crnl + "abc").matches() && |
65a14579a2ae
8176029: Linebreak matcher is not equivalent to the pattern as stated in javadoc
sherman
parents:
38777
diff
changeset
|
4637 |
Pattern.compile("\\Rabc").matcher("\rabc").matches() && |
65a14579a2ae
8176029: Linebreak matcher is not equivalent to the pattern as stated in javadoc
sherman
parents:
38777
diff
changeset
|
4638 |
Pattern.compile("\\R\\R").matcher(crnl).matches() && // backtracking |
65a14579a2ae
8176029: Linebreak matcher is not equivalent to the pattern as stated in javadoc
sherman
parents:
38777
diff
changeset
|
4639 |
Pattern.compile("\\R\\n").matcher(crnl).matches()) && // backtracking |
65a14579a2ae
8176029: Linebreak matcher is not equivalent to the pattern as stated in javadoc
sherman
parents:
38777
diff
changeset
|
4640 |
!Pattern.compile("((?<!\\R)\\s)*").matcher(crnl).matches()) { // #8176029 |
65a14579a2ae
8176029: Linebreak matcher is not equivalent to the pattern as stated in javadoc
sherman
parents:
38777
diff
changeset
|
4641 |
failCount++; |
65a14579a2ae
8176029: Linebreak matcher is not equivalent to the pattern as stated in javadoc
sherman
parents:
38777
diff
changeset
|
4642 |
} |
12675
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4643 |
report("linebreakTest"); |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4644 |
} |
3b7d71495649
7014640: To add a metachar \R for line ending and character classes for vertical/horizontal ws \v \V \h \H
sherman
parents:
12432
diff
changeset
|
4645 |
|
13554
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4646 |
// #7189363 |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4647 |
private static void branchTest() throws Exception { |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4648 |
if (!Pattern.compile("(a)?bc|d").matcher("d").find() || // greedy |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4649 |
!Pattern.compile("(a)+bc|d").matcher("d").find() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4650 |
!Pattern.compile("(a)*bc|d").matcher("d").find() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4651 |
!Pattern.compile("(a)??bc|d").matcher("d").find() || // reluctant |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4652 |
!Pattern.compile("(a)+?bc|d").matcher("d").find() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4653 |
!Pattern.compile("(a)*?bc|d").matcher("d").find() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4654 |
!Pattern.compile("(a)?+bc|d").matcher("d").find() || // possessive |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4655 |
!Pattern.compile("(a)++bc|d").matcher("d").find() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4656 |
!Pattern.compile("(a)*+bc|d").matcher("d").find() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4657 |
!Pattern.compile("(a)?bc|d").matcher("d").matches() || // greedy |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4658 |
!Pattern.compile("(a)+bc|d").matcher("d").matches() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4659 |
!Pattern.compile("(a)*bc|d").matcher("d").matches() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4660 |
!Pattern.compile("(a)??bc|d").matcher("d").matches() || // reluctant |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4661 |
!Pattern.compile("(a)+?bc|d").matcher("d").matches() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4662 |
!Pattern.compile("(a)*?bc|d").matcher("d").matches() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4663 |
!Pattern.compile("(a)?+bc|d").matcher("d").matches() || // possessive |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4664 |
!Pattern.compile("(a)++bc|d").matcher("d").matches() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4665 |
!Pattern.compile("(a)*+bc|d").matcher("d").matches() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4666 |
!Pattern.compile("(a)?bc|de").matcher("de").find() || // others |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4667 |
!Pattern.compile("(a)??bc|de").matcher("de").find() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4668 |
!Pattern.compile("(a)?bc|de").matcher("de").matches() || |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4669 |
!Pattern.compile("(a)??bc|de").matcher("de").matches()) |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4670 |
failCount++; |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4671 |
report("branchTest"); |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4672 |
} |
ad737436c54a
7189363: Regex Pattern compilation buggy for special sequences
sherman
parents:
12675
diff
changeset
|
4673 |
|
17183
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4674 |
// This test is for 8007395 |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4675 |
private static void groupCurlyNotFoundSuppTest() throws Exception { |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4676 |
String input = "test this as \ud83d\ude0d"; |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4677 |
for (String pStr : new String[] { "test(.)+(@[a-zA-Z.]+)", |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4678 |
"test(.)*(@[a-zA-Z.]+)", |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4679 |
"test([^B])+(@[a-zA-Z.]+)", |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4680 |
"test([^B])*(@[a-zA-Z.]+)", |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4681 |
"test(\\P{IsControl})+(@[a-zA-Z.]+)", |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4682 |
"test(\\P{IsControl})*(@[a-zA-Z.]+)", |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4683 |
}) { |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4684 |
Matcher m = Pattern.compile(pStr, Pattern.CASE_INSENSITIVE) |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4685 |
.matcher(input); |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4686 |
try { |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4687 |
if (m.find()) { |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4688 |
failCount++; |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4689 |
} |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4690 |
} catch (Exception x) { |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4691 |
failCount++; |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4692 |
} |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4693 |
} |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4694 |
report("GroupCurly NotFoundSupp"); |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4695 |
} |
1e21e0bc10e7
8007395: StringIndexOutofBoundsException in Match.find() when input String contains surrogate UTF-16 characters
sherman
parents:
14342
diff
changeset
|
4696 |
|
19604
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
4697 |
// This test is for 8023647 |
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
4698 |
private static void groupCurlyBackoffTest() throws Exception { |
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
4699 |
if (!"abc1c".matches("(\\w)+1\\1") || |
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
4700 |
"abc11".matches("(\\w)+1\\1")) { |
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
4701 |
failCount++; |
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
4702 |
} |
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
4703 |
report("GroupCurly backoff"); |
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
4704 |
} |
f96e3aef2081
8023647: "abc1c".matches("(\\w)+1\\1")) returns false
sherman
parents:
17447
diff
changeset
|
4705 |
|
17447 | 4706 |
// This test is for 8012646 |
4707 |
private static void patternAsPredicate() throws Exception { |
|
4708 |
Predicate<String> p = Pattern.compile("[a-z]+").asPredicate(); |
|
4709 |
||
4710 |
if (p.test("")) { |
|
4711 |
failCount++; |
|
4712 |
} |
|
4713 |
if (!p.test("word")) { |
|
4714 |
failCount++; |
|
4715 |
} |
|
4716 |
if (p.test("1234")) { |
|
4717 |
failCount++; |
|
4718 |
} |
|
49554
f088ec60bed5
8164781: Pattern.asPredicate specification is incomplete
vtheeyarath
parents:
48853
diff
changeset
|
4719 |
if (!p.test("word1234")) { |
f088ec60bed5
8164781: Pattern.asPredicate specification is incomplete
vtheeyarath
parents:
48853
diff
changeset
|
4720 |
failCount++; |
f088ec60bed5
8164781: Pattern.asPredicate specification is incomplete
vtheeyarath
parents:
48853
diff
changeset
|
4721 |
} |
17447 | 4722 |
report("Pattern.asPredicate"); |
4723 |
} |
|
25523
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4724 |
|
49763 | 4725 |
// This test is for 8184692 |
4726 |
private static void patternAsMatchPredicate() throws Exception { |
|
4727 |
Predicate<String> p = Pattern.compile("[a-z]+").asMatchPredicate(); |
|
4728 |
||
4729 |
if (p.test("")) { |
|
4730 |
failCount++; |
|
4731 |
} |
|
4732 |
if (!p.test("word")) { |
|
4733 |
failCount++; |
|
4734 |
} |
|
4735 |
if (p.test("1234word")) { |
|
4736 |
failCount++; |
|
4737 |
} |
|
4738 |
if (p.test("1234")) { |
|
4739 |
failCount++; |
|
4740 |
} |
|
4741 |
report("Pattern.asMatchPredicate"); |
|
4742 |
} |
|
4743 |
||
4744 |
||
25523
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4745 |
// This test is for 8035975 |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4746 |
private static void invalidFlags() throws Exception { |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4747 |
for (int flag = 1; flag != 0; flag <<= 1) { |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4748 |
switch (flag) { |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4749 |
case Pattern.CASE_INSENSITIVE: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4750 |
case Pattern.MULTILINE: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4751 |
case Pattern.DOTALL: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4752 |
case Pattern.UNICODE_CASE: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4753 |
case Pattern.CANON_EQ: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4754 |
case Pattern.UNIX_LINES: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4755 |
case Pattern.LITERAL: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4756 |
case Pattern.UNICODE_CHARACTER_CLASS: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4757 |
case Pattern.COMMENTS: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4758 |
// valid flag, continue |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4759 |
break; |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4760 |
default: |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4761 |
try { |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4762 |
Pattern.compile(".", flag); |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4763 |
failCount++; |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4764 |
} catch (IllegalArgumentException expected) { |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4765 |
} |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4766 |
} |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4767 |
} |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4768 |
report("Invalid compile flags"); |
c751d1010164
8035975: Pattern.compile(String, int) fails to throw IllegalArgumentException
igerasim
parents:
23734
diff
changeset
|
4769 |
} |
35783
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4770 |
|
38777
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4771 |
// This test is for 8158482 |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4772 |
private static void embeddedFlags() throws Exception { |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4773 |
try { |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4774 |
Pattern.compile("(?i).(?-i)."); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4775 |
Pattern.compile("(?m).(?-m)."); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4776 |
Pattern.compile("(?s).(?-s)."); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4777 |
Pattern.compile("(?d).(?-d)."); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4778 |
Pattern.compile("(?u).(?-u)."); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4779 |
Pattern.compile("(?c).(?-c)."); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4780 |
Pattern.compile("(?x).(?-x)."); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4781 |
Pattern.compile("(?U).(?-U)."); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4782 |
Pattern.compile("(?imsducxU).(?-imsducxU)."); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4783 |
} catch (PatternSyntaxException x) { |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4784 |
failCount++; |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4785 |
} |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4786 |
report("Embedded flags"); |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4787 |
} |
826eb7091523
8158482: regex UNICODE_CHARACTER_CLASS flag cannot be disabled with an embedded flag expression
sherman
parents:
38450
diff
changeset
|
4788 |
|
35783
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4789 |
private static void grapheme() throws Exception { |
55013 | 4790 |
Files.lines(UCDFiles.GRAPHEME_BREAK_TEST) |
35783
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4791 |
.filter( ln -> ln.length() != 0 && !ln.startsWith("#") ) |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4792 |
.forEach( ln -> { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4793 |
ln = ln.replaceAll("\\s+|\\([a-zA-Z]+\\)|\\[[a-zA-Z]]+\\]|#.*", ""); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4794 |
// System.out.println(str); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4795 |
String[] strs = ln.split("\u00f7|\u00d7"); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4796 |
StringBuilder src = new StringBuilder(); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4797 |
ArrayList<String> graphemes = new ArrayList<>(); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4798 |
StringBuilder buf = new StringBuilder(); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4799 |
int offBk = 0; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4800 |
for (String str : strs) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4801 |
if (str.length() == 0) // first empty str |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4802 |
continue; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4803 |
int cp = Integer.parseInt(str, 16); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4804 |
src.appendCodePoint(cp); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4805 |
buf.appendCodePoint(cp); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4806 |
offBk += (str.length() + 1); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4807 |
if (ln.charAt(offBk) == '\u00f7') { // DIV |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4808 |
graphemes.add(buf.toString()); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4809 |
buf = new StringBuilder(); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4810 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4811 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4812 |
Pattern p = Pattern.compile("\\X"); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4813 |
Matcher m = p.matcher(src.toString()); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4814 |
Scanner s = new Scanner(src.toString()).useDelimiter("\\b{g}"); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4815 |
for (String g : graphemes) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4816 |
// System.out.printf(" grapheme:=[%s]%n", g); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4817 |
// (1) test \\X directly |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4818 |
if (!m.find() || !m.group().equals(g)) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4819 |
System.out.println("Failed \\X [" + ln + "] : " + g); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4820 |
failCount++; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4821 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4822 |
// (2) test \\b{g} + \\X via Scanner |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4823 |
boolean hasNext = s.hasNext(p); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4824 |
// if (!s.hasNext() || !s.next().equals(next)) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4825 |
if (!s.hasNext(p) || !s.next(p).equals(g)) { |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4826 |
System.out.println("Failed b{g} [" + ln + "] : " + g); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4827 |
failCount++; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4828 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4829 |
} |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4830 |
}); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4831 |
// some sanity checks |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4832 |
if (!Pattern.compile("\\X{10}").matcher("abcdefghij").matches() || |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4833 |
!Pattern.compile("\\b{g}(?:\\X\\b{g}){5}\\b{g}").matcher("abcde").matches() || |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4834 |
!Pattern.compile("(?:\\X\\b{g}){2}").matcher("\ud800\udc00\ud801\udc02").matches()) |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4835 |
failCount++; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4836 |
// make sure "\b{n}" still works |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4837 |
if (!Pattern.compile("\\b{1}hello\\b{1} \\b{1}world\\b{1}").matcher("hello world").matches()) |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4838 |
failCount++; |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4839 |
report("Unicode extended grapheme cluster"); |
2690535d72cc
7071819: To support Extended Grapheme Clusters in Regex
sherman
parents:
34436
diff
changeset
|
4840 |
} |
37882
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4841 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4842 |
// hangup/timeout if go into exponential backtracking |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4843 |
private static void expoBacktracking() throws Exception { |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4844 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4845 |
Object[][] patternMatchers = { |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4846 |
// 6328855 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4847 |
{ "(.*\n*)*", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4848 |
"this little fine string lets\r\njava.lang.String.matches\r\ncrash\r\n(We don't know why but adding \r* to the regex makes it work again)", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4849 |
false }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4850 |
// 6192895 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4851 |
{ " *([a-zA-Z0-9/\\-\\?:\\(\\)\\.,'\\+\\{\\}]+ *)+", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4852 |
"Hello World this is a test this is a test this is a test A", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4853 |
true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4854 |
{ " *([a-zA-Z0-9/\\-\\?:\\(\\)\\.,'\\+\\{\\}]+ *)+", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4855 |
"Hello World this is a test this is a test this is a test \u4e00 ", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4856 |
false }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4857 |
{ " *([a-z0-9]+ *)+", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4858 |
"hello world this is a test this is a test this is a test A", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4859 |
false }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4860 |
// 4771934 [FIXED] #5013651? |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4861 |
{ "^(\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*(\\.\\w{2,4})+[,;]?)+$", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4862 |
"abc@efg.abc,efg@abc.abc,abc@xyz.mno;abc@sdfsd.com", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4863 |
true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4864 |
// 4866249 [FIXED] |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4865 |
{ "<\\s*" + "(meta|META)" + "(\\s|[^>])+" + "(CHARSET|charset)=" + "(\\s|[^>])+>", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4866 |
"<META http-equiv=\"Content-Type\" content=\"text/html; charset=ISO-8859-5\">", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4867 |
true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4868 |
{ "^(\\w+([\\.-]?\\w+)*@\\w+([\\.-]?\\w+)*(\\.\\w{2,4})+[,;]?)+$", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4869 |
"abc@efg.abc,efg@abc.abc,abc@xyz.mno;sdfsd.com", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4870 |
false }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4871 |
// 6345469 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4872 |
{ "((<[^>]+>)?(((\\s)?)*(\\ )?)*((\\s)?)*)+", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4873 |
" < br/> < / p> <p> <html> <adfasfdasdf> </p>", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4874 |
true }, // --> matched |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4875 |
{ "((<[^>]+>)?(((\\s)?)*(\\ )?)*((\\s)?)*)+", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4876 |
" < br/> < / p> <p> <html> <adfasfdasdf> p </p>", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4877 |
false }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4878 |
// 5026912 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4879 |
{ "^\\s*" + "(\\w|\\d|[\\xC0-\\xFF]|/)+" + "\\s+|$", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4880 |
"156580451111112225588087755221111111566969655555555", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4881 |
false}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4882 |
// 6988218 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4883 |
{ "^([+-]?((0[xX](\\p{XDigit}+))|(((\\p{Digit}+)(\\.)?((\\p{Digit}+)?)([eE][+-]?(\\p{Digit}+))?)|(\\.((\\p{Digit}+))([eE][+-]?(\\p{Digit}+))?)))|[n|N]?'([^']*(?:'')*[^']*)*')", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4884 |
"'%)) order by ANGEBOT.ID", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4885 |
false}, // find |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4886 |
// 6693451 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4887 |
{ "^(\\s*foo\\s*)*$", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4888 |
"foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4889 |
true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4890 |
{ "^(\\s*foo\\s*)*$", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4891 |
"foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo foo fo", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4892 |
false |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4893 |
}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4894 |
// 7006761 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4895 |
{ "(([0-9A-Z]+)([_]?+)*)*", "FOOOOO_BAAAR_FOOOOOOOOO_BA_", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4896 |
{ "(([0-9A-Z]+)([_]?+)*)*", "FOOOOO_BAAAR_FOOOOOOOOO_BA_ ", false}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4897 |
// 8140212 |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4898 |
{ "(?<before>.*)\\{(?<reflection>\\w+):(?<innerMethod>\\w+(\\.?\\w+(\\(((?<args>(('[^']*')|((/|\\w)+))(,(('[^']*')|((/|\\w)+)))*))?\\))?)*)\\}(?<after>.*)", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4899 |
"{CeGlobal:getSodCutoff.getGui.getAmqp.getSimpleModeEnabled()", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4900 |
false |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4901 |
}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4902 |
{ "^(a+)+$", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4903 |
{ "^(a+)+$", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa!", false}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4904 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4905 |
{ "(x+)*y", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy", true }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4906 |
{ "(x+)*y", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz", false}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4907 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4908 |
{ "(x+x+)+y", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy", true}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4909 |
{ "(x+x+)+y", "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz", false}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4910 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4911 |
{ "(([0-9A-Z]+)([_]?+)*)*", "--------------------------------------", false}, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4912 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4913 |
/* not fixed |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4914 |
//8132141 ---> second level exponential backtracking |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4915 |
{ "(h|h|ih(((i|a|c|c|a|i|i|j|b|a|i|b|a|a|j))+h)ahbfhba|c|i)*", |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4916 |
"hchcchicihcchciiicichhcichcihcchiihichiciiiihhcchicchhcihchcihiihciichhccciccichcichiihcchcihhicchcciicchcccihiiihhihihihichicihhcciccchihhhcchichchciihiicihciihcccciciccicciiiiiiiiicihhhiiiihchccchchhhhiiihchihcccchhhiiiiiiiicicichicihcciciihichhhhchihciiihhiccccccciciihhichiccchhicchicihihccichicciihcichccihhiciccccccccichhhhihihhcchchihihiihhihihihicichihiiiihhhhihhhchhichiicihhiiiiihchccccchichci" }, |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4917 |
*/ |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4918 |
}; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4919 |
|
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4920 |
for (Object[] pm : patternMatchers) { |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4921 |
String p = (String)pm[0]; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4922 |
String s = (String)pm[1]; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4923 |
boolean r = (Boolean)pm[2]; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4924 |
if (r != Pattern.compile(p).matcher(s).matches()) { |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4925 |
failCount++; |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4926 |
} |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4927 |
} |
e7f3cf12e739
6328855: String: Matches hangs at short and easy Strings containing \r \n
sherman
parents:
35783
diff
changeset
|
4928 |
} |
48853
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4929 |
|
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4930 |
private static void invalidGroupName() { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4931 |
// Invalid start of a group name |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4932 |
for (String groupName : List.of("", ".", "0", "\u0040", "\u005b", |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4933 |
"\u0060", "\u007b", "\u0416")) { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4934 |
for (String pat : List.of("(?<" + groupName + ">)", |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4935 |
"\\k<" + groupName + ">")) { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4936 |
try { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4937 |
Pattern.compile(pat); |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4938 |
failCount++; |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4939 |
} catch (PatternSyntaxException e) { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4940 |
if (!e.getMessage().startsWith( |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4941 |
"capturing group name does not start with a" |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4942 |
+ " Latin letter")) { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4943 |
failCount++; |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4944 |
} |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4945 |
} |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4946 |
} |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4947 |
} |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4948 |
// Invalid char in a group name |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4949 |
for (String groupName : List.of("a.", "b\u0040", "c\u005b", |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4950 |
"d\u0060", "e\u007b", "f\u0416")) { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4951 |
for (String pat : List.of("(?<" + groupName + ">)", |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4952 |
"\\k<" + groupName + ">")) { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4953 |
try { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4954 |
Pattern.compile(pat); |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4955 |
failCount++; |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4956 |
} catch (PatternSyntaxException e) { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4957 |
if (!e.getMessage().startsWith( |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4958 |
"named capturing group is missing trailing '>'")) { |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4959 |
failCount++; |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4960 |
} |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4961 |
} |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4962 |
} |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4963 |
} |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4964 |
report("Invalid capturing group names"); |
84b4ffbba8b0
8197462: Inconsistent exception messages for invalid capturing group names
igerasim
parents:
48491
diff
changeset
|
4965 |
} |
55096
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4966 |
|
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4967 |
private static void illegalRepetitionRange() { |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4968 |
// huge integers > (2^31 - 1) |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4969 |
String n = BigInteger.valueOf(1L << 32) |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4970 |
.toString(); |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4971 |
String m = BigInteger.valueOf(1L << 31) |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4972 |
.add(new BigInteger(80, generator)) |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4973 |
.toString(); |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4974 |
for (String rep : List.of("", "x", ".", ",", "-1", "2,1", |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4975 |
n, n + ",", "0," + n, n + "," + m, m, m + ",", "0," + m)) { |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4976 |
String pat = ".{" + rep + "}"; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4977 |
try { |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4978 |
Pattern.compile(pat); |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4979 |
failCount++; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4980 |
System.out.println("Expected to fail. Pattern: " + pat); |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4981 |
} catch (PatternSyntaxException e) { |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4982 |
if (!e.getMessage().startsWith("Illegal repetition")) { |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4983 |
failCount++; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4984 |
System.out.println("Unexpected error message: " + e.getMessage()); |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4985 |
} |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4986 |
} catch (Throwable t) { |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4987 |
failCount++; |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4988 |
System.out.println("Unexpected exception: " + t); |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4989 |
} |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4990 |
} |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4991 |
report("illegalRepetitionRange"); |
234673929e0a
8224789: Parsing repetition count in regex does not detect numeric overflow
igerasim
parents:
55013
diff
changeset
|
4992 |
} |
57624
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
4993 |
|
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
4994 |
private static void surrogatePairWithCanonEq() { |
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
4995 |
try { |
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
4996 |
Pattern.compile("\ud834\udd21", Pattern.CANON_EQ); |
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
4997 |
} catch (Throwable t) { |
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
4998 |
failCount++; |
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
4999 |
System.out.println("Unexpected exception: " + t); |
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
5000 |
} |
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
5001 |
report("surrogatePairWithCanonEq"); |
67e58672c503
8228352: CANON_EQ breaks when pattern contains supplementary codepoint
igerasim
parents:
55096
diff
changeset
|
5002 |
} |
2070
6e9972fbd965
6350801: Add support for named (instead of numbered) capture groups in regular expression
sherman
parents:
diff
changeset
|
5003 |
} |