Lines 34-53
Link Here
|
34 |
import java.lang.reflect.Field; |
34 |
import java.lang.reflect.Field; |
35 |
import java.util.regex.Matcher; |
35 |
import java.util.regex.Matcher; |
36 |
import java.util.regex.Pattern; |
36 |
import java.util.regex.Pattern; |
|
|
37 |
import org.netbeans.api.search.SearchPattern; |
38 |
import org.netbeans.api.search.SearchPattern.MatchType; |
37 |
import org.netbeans.junit.NbTestCase; |
39 |
import org.netbeans.junit.NbTestCase; |
38 |
|
40 |
|
39 |
/** |
41 |
/** |
40 |
* |
42 |
* |
41 |
* @author mp |
43 |
* @author mp |
42 |
*/ |
44 |
*/ |
43 |
public class RegexpMakerTest extends NbTestCase { |
45 |
public class TextRegexpUtilTest extends NbTestCase { |
44 |
|
46 |
|
45 |
public RegexpMakerTest() { |
47 |
public TextRegexpUtilTest() { |
46 |
super("SimpleRegexpParserTest"); |
48 |
super("SimpleRegexpParserTest"); |
47 |
} |
49 |
} |
48 |
|
50 |
|
49 |
private static String getClassField(String name) throws Exception { |
51 |
private static String getClassField(String name) throws Exception { |
50 |
Field field = RegexpMaker.class.getDeclaredField(name); |
52 |
Field field = TextRegexpUtil.class.getDeclaredField(name); |
51 |
field.setAccessible(true); |
53 |
field.setAccessible(true); |
52 |
return (String) field.get(null); |
54 |
return (String) field.get(null); |
53 |
} |
55 |
} |
Lines 55-99
Link Here
|
55 |
public void testMakeRegexp() throws Exception { |
57 |
public void testMakeRegexp() throws Exception { |
56 |
|
58 |
|
57 |
/* basics: */ |
59 |
/* basics: */ |
58 |
assertEquals("", RegexpMaker.makeRegexp("")); |
60 |
assertEquals("", makeRegexp("")); |
59 |
assertEquals("a", RegexpMaker.makeRegexp("a")); |
61 |
assertEquals("a", makeRegexp("a")); |
60 |
assertEquals("ab", RegexpMaker.makeRegexp("ab")); |
62 |
assertEquals("ab", makeRegexp("ab")); |
61 |
assertEquals("abc", RegexpMaker.makeRegexp("abc")); |
63 |
assertEquals("abc", makeRegexp("abc")); |
62 |
|
64 |
|
63 |
/* special chars in the middle: */ |
65 |
/* special chars in the middle: */ |
64 |
assertEquals("a.*?b.c", RegexpMaker.makeRegexp("a*b?c")); |
66 |
assertEquals("a.*?b.c", makeRegexp("a*b?c")); |
65 |
assertEquals("a..+?b", RegexpMaker.makeRegexp("a?*?b")); |
67 |
assertEquals("a..+?b", makeRegexp("a?*?b")); |
66 |
assertEquals("a.+?b", RegexpMaker.makeRegexp("a*?*b")); |
68 |
assertEquals("a.+?b", makeRegexp("a*?*b")); |
67 |
|
69 |
|
68 |
/* ignore stars in the begining: */ |
70 |
/* ignore stars in the begining: */ |
69 |
assertEquals("a", RegexpMaker.makeRegexp("*a")); |
71 |
assertEquals("a", makeRegexp("*a")); |
70 |
assertEquals(".a", RegexpMaker.makeRegexp("?a")); |
72 |
assertEquals(".a", makeRegexp("?a")); |
71 |
assertEquals("a", RegexpMaker.makeRegexp("**a")); |
73 |
assertEquals("a", makeRegexp("**a")); |
72 |
assertEquals(".a", RegexpMaker.makeRegexp("*?a")); |
74 |
assertEquals(".a", makeRegexp("*?a")); |
73 |
assertEquals(".a", RegexpMaker.makeRegexp("?*a")); |
75 |
assertEquals(".a", makeRegexp("?*a")); |
74 |
assertEquals("..a", RegexpMaker.makeRegexp("??a")); |
76 |
assertEquals("..a", makeRegexp("??a")); |
75 |
|
77 |
|
76 |
/* ignore stars at the end: */ |
78 |
/* ignore stars at the end: */ |
77 |
assertEquals("a", RegexpMaker.makeRegexp("a*")); |
79 |
assertEquals("a", makeRegexp("a*")); |
78 |
assertEquals("a.", RegexpMaker.makeRegexp("a?")); |
80 |
assertEquals("a.", makeRegexp("a?")); |
79 |
assertEquals("a", RegexpMaker.makeRegexp("a**")); |
81 |
assertEquals("a", makeRegexp("a**")); |
80 |
assertEquals("a.", RegexpMaker.makeRegexp("a*?")); |
82 |
assertEquals("a.", makeRegexp("a*?")); |
81 |
assertEquals("a.", RegexpMaker.makeRegexp("a?*")); |
83 |
assertEquals("a.", makeRegexp("a?*")); |
82 |
assertEquals("a..", RegexpMaker.makeRegexp("a??")); |
84 |
assertEquals("a..", makeRegexp("a??")); |
83 |
|
85 |
|
84 |
/* other usage of '*' and '?': */ |
86 |
/* other usage of '*' and '?': */ |
85 |
assertEquals(" .*?a", RegexpMaker.makeRegexp(" *a")); |
87 |
assertEquals(" .*?a", makeRegexp(" *a")); |
86 |
assertEquals(" .a", RegexpMaker.makeRegexp(" ?a")); |
88 |
assertEquals(" .a", makeRegexp(" ?a")); |
87 |
assertEquals(" a", RegexpMaker.makeRegexp("* a")); |
89 |
assertEquals(" a", makeRegexp("* a")); |
88 |
assertEquals(". a", RegexpMaker.makeRegexp("? a")); |
90 |
assertEquals(". a", makeRegexp("? a")); |
89 |
assertEquals("\\,a", RegexpMaker.makeRegexp("*,a")); |
91 |
assertEquals("\\,a", makeRegexp("*,a")); |
90 |
assertEquals(".\\,a", RegexpMaker.makeRegexp("?,a")); |
92 |
assertEquals(".\\,a", makeRegexp("?,a")); |
91 |
assertEquals("a.*? ", RegexpMaker.makeRegexp("a* ")); |
93 |
assertEquals("a.*? ", makeRegexp("a* ")); |
92 |
assertEquals("a. ", RegexpMaker.makeRegexp("a? ")); |
94 |
assertEquals("a. ", makeRegexp("a? ")); |
93 |
assertEquals("a ", RegexpMaker.makeRegexp("a *")); |
95 |
assertEquals("a ", makeRegexp("a *")); |
94 |
assertEquals("a .", RegexpMaker.makeRegexp("a ?")); |
96 |
assertEquals("a .", makeRegexp("a ?")); |
95 |
assertEquals("a\\,", RegexpMaker.makeRegexp("a,*")); |
97 |
assertEquals("a\\,", makeRegexp("a,*")); |
96 |
assertEquals("a\\,.", RegexpMaker.makeRegexp("a,?")); |
98 |
assertEquals("a\\,.", makeRegexp("a,?")); |
97 |
|
99 |
|
98 |
/* whole words: */ |
100 |
/* whole words: */ |
99 |
|
101 |
|
Lines 101-251
Link Here
|
101 |
final String checkNotAfterWordChar = getClassField("checkNotAfterWordChar"); |
103 |
final String checkNotAfterWordChar = getClassField("checkNotAfterWordChar"); |
102 |
final String checkNotBeforeWordChar = getClassField("checkNotBeforeWordChar"); |
104 |
final String checkNotBeforeWordChar = getClassField("checkNotBeforeWordChar"); |
103 |
|
105 |
|
104 |
assertEquals("", RegexpMaker.makeRegexp("", true)); |
106 |
assertEquals("", makeRegexp("", true)); |
105 |
assertEquals(checkNotAfterWordChar + "a" + checkNotBeforeWordChar, |
107 |
assertEquals(checkNotAfterWordChar + "a" + checkNotBeforeWordChar, |
106 |
RegexpMaker.makeRegexp("a", true)); |
108 |
makeRegexp("a", true)); |
107 |
assertEquals(checkNotAfterWordChar |
109 |
assertEquals(checkNotAfterWordChar |
108 |
+ "a" + wordCharsExpr + "*?b" + wordCharsExpr + "c" |
110 |
+ "a" + wordCharsExpr + "*?b" + wordCharsExpr + "c" |
109 |
+ checkNotBeforeWordChar, |
111 |
+ checkNotBeforeWordChar, |
110 |
RegexpMaker.makeRegexp("a*b?c", true)); |
112 |
makeRegexp("a*b?c", true)); |
111 |
assertEquals(checkNotAfterWordChar |
113 |
assertEquals(checkNotAfterWordChar |
112 |
+ "a" + wordCharsExpr + "{2,}?b" |
114 |
+ "a" + wordCharsExpr + "{2,}?b" |
113 |
+ checkNotBeforeWordChar, |
115 |
+ checkNotBeforeWordChar, |
114 |
RegexpMaker.makeRegexp("a?*?b", true)); |
116 |
makeRegexp("a?*?b", true)); |
115 |
assertEquals(checkNotAfterWordChar |
117 |
assertEquals(checkNotAfterWordChar |
116 |
+ "a" + wordCharsExpr + "+?b" |
118 |
+ "a" + wordCharsExpr + "+?b" |
117 |
+ checkNotBeforeWordChar, |
119 |
+ checkNotBeforeWordChar, |
118 |
RegexpMaker.makeRegexp("a*?*b", true)); |
120 |
makeRegexp("a*?*b", true)); |
119 |
|
121 |
|
120 |
assertEquals(wordCharsExpr + "*a" + checkNotBeforeWordChar, |
122 |
assertEquals(wordCharsExpr + "*a" + checkNotBeforeWordChar, |
121 |
RegexpMaker.makeRegexp("*a", true)); |
123 |
makeRegexp("*a", true)); |
122 |
assertEquals(checkNotAfterWordChar + wordCharsExpr + "a" + checkNotBeforeWordChar, |
124 |
assertEquals(checkNotAfterWordChar + wordCharsExpr + "a" + checkNotBeforeWordChar, |
123 |
RegexpMaker.makeRegexp("?a", true)); |
125 |
makeRegexp("?a", true)); |
124 |
assertEquals(wordCharsExpr + "*a" + checkNotBeforeWordChar, |
126 |
assertEquals(wordCharsExpr + "*a" + checkNotBeforeWordChar, |
125 |
RegexpMaker.makeRegexp("**a", true)); |
127 |
makeRegexp("**a", true)); |
126 |
assertEquals(wordCharsExpr + "+a" + checkNotBeforeWordChar, |
128 |
assertEquals(wordCharsExpr + "+a" + checkNotBeforeWordChar, |
127 |
RegexpMaker.makeRegexp("*?a", true)); |
129 |
makeRegexp("*?a", true)); |
128 |
assertEquals(wordCharsExpr + "+a" + checkNotBeforeWordChar, |
130 |
assertEquals(wordCharsExpr + "+a" + checkNotBeforeWordChar, |
129 |
RegexpMaker.makeRegexp("?*a", true)); |
131 |
makeRegexp("?*a", true)); |
130 |
assertEquals(checkNotAfterWordChar + wordCharsExpr + "{2}a" + checkNotBeforeWordChar, |
132 |
assertEquals(checkNotAfterWordChar + wordCharsExpr + "{2}a" + checkNotBeforeWordChar, |
131 |
RegexpMaker.makeRegexp("??a", true)); |
133 |
makeRegexp("??a", true)); |
132 |
|
134 |
|
133 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "*", |
135 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "*", |
134 |
RegexpMaker.makeRegexp("a*", true)); |
136 |
makeRegexp("a*", true)); |
135 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + checkNotBeforeWordChar, |
137 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + checkNotBeforeWordChar, |
136 |
RegexpMaker.makeRegexp("a?", true)); |
138 |
makeRegexp("a?", true)); |
137 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "*", |
139 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "*", |
138 |
RegexpMaker.makeRegexp("a**", true)); |
140 |
makeRegexp("a**", true)); |
139 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "+", |
141 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "+", |
140 |
RegexpMaker.makeRegexp("a*?", true)); |
142 |
makeRegexp("a*?", true)); |
141 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "+", |
143 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "+", |
142 |
RegexpMaker.makeRegexp("a?*", true)); |
144 |
makeRegexp("a?*", true)); |
143 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "{2}" + checkNotBeforeWordChar, |
145 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "{2}" + checkNotBeforeWordChar, |
144 |
RegexpMaker.makeRegexp("a??", true)); |
146 |
makeRegexp("a??", true)); |
145 |
|
147 |
|
146 |
assertEquals(" " + wordCharsExpr + "*?a" + checkNotBeforeWordChar, |
148 |
assertEquals(" " + wordCharsExpr + "*?a" + checkNotBeforeWordChar, |
147 |
RegexpMaker.makeRegexp(" *a", true)); |
149 |
makeRegexp(" *a", true)); |
148 |
assertEquals(" " + wordCharsExpr + "a" + checkNotBeforeWordChar, |
150 |
assertEquals(" " + wordCharsExpr + "a" + checkNotBeforeWordChar, |
149 |
RegexpMaker.makeRegexp(" ?a", true)); |
151 |
makeRegexp(" ?a", true)); |
150 |
assertEquals(wordCharsExpr + "* a" + checkNotBeforeWordChar, |
152 |
assertEquals(wordCharsExpr + "* a" + checkNotBeforeWordChar, |
151 |
RegexpMaker.makeRegexp("* a", true)); |
153 |
makeRegexp("* a", true)); |
152 |
assertEquals(checkNotAfterWordChar + wordCharsExpr + " a" + checkNotBeforeWordChar, |
154 |
assertEquals(checkNotAfterWordChar + wordCharsExpr + " a" + checkNotBeforeWordChar, |
153 |
RegexpMaker.makeRegexp("? a", true)); |
155 |
makeRegexp("? a", true)); |
154 |
assertEquals(wordCharsExpr + "*\\,a" + checkNotBeforeWordChar, |
156 |
assertEquals(wordCharsExpr + "*\\,a" + checkNotBeforeWordChar, |
155 |
RegexpMaker.makeRegexp("*,a", true)); |
157 |
makeRegexp("*,a", true)); |
156 |
assertEquals(checkNotAfterWordChar + wordCharsExpr + "\\,a" + checkNotBeforeWordChar, |
158 |
assertEquals(checkNotAfterWordChar + wordCharsExpr + "\\,a" + checkNotBeforeWordChar, |
157 |
RegexpMaker.makeRegexp("?,a", true)); |
159 |
makeRegexp("?,a", true)); |
158 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "*? ", |
160 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + "*? ", |
159 |
RegexpMaker.makeRegexp("a* ", true)); |
161 |
makeRegexp("a* ", true)); |
160 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + " ", |
162 |
assertEquals(checkNotAfterWordChar + "a" + wordCharsExpr + " ", |
161 |
RegexpMaker.makeRegexp("a? ", true)); |
163 |
makeRegexp("a? ", true)); |
162 |
assertEquals(checkNotAfterWordChar + "a " + wordCharsExpr + "*", |
164 |
assertEquals(checkNotAfterWordChar + "a " + wordCharsExpr + "*", |
163 |
RegexpMaker.makeRegexp("a *", true)); |
165 |
makeRegexp("a *", true)); |
164 |
assertEquals(checkNotAfterWordChar + "a " + wordCharsExpr + checkNotBeforeWordChar, |
166 |
assertEquals(checkNotAfterWordChar + "a " + wordCharsExpr + checkNotBeforeWordChar, |
165 |
RegexpMaker.makeRegexp("a ?", true)); |
167 |
makeRegexp("a ?", true)); |
166 |
assertEquals(checkNotAfterWordChar + "a\\," + wordCharsExpr + "*", |
168 |
assertEquals(checkNotAfterWordChar + "a\\," + wordCharsExpr + "*", |
167 |
RegexpMaker.makeRegexp("a,*", true)); |
169 |
makeRegexp("a,*", true)); |
168 |
assertEquals(checkNotAfterWordChar + "a\\," + wordCharsExpr + checkNotBeforeWordChar, |
170 |
assertEquals(checkNotAfterWordChar + "a\\," + wordCharsExpr + checkNotBeforeWordChar, |
169 |
RegexpMaker.makeRegexp("a,?", true)); |
171 |
makeRegexp("a,?", true)); |
170 |
|
172 |
|
171 |
assertEquals("a b", RegexpMaker.makeRegexp("a b")); |
173 |
assertEquals("a b", makeRegexp("a b")); |
172 |
assertEquals("a\\!b", RegexpMaker.makeRegexp("a!b")); |
174 |
assertEquals("a\\!b", makeRegexp("a!b")); |
173 |
assertEquals("a\\\"b", RegexpMaker.makeRegexp("a\"b")); |
175 |
assertEquals("a\\\"b", makeRegexp("a\"b")); |
174 |
assertEquals("a\\#b", RegexpMaker.makeRegexp("a#b")); |
176 |
assertEquals("a\\#b", makeRegexp("a#b")); |
175 |
assertEquals("a\\$b", RegexpMaker.makeRegexp("a$b")); |
177 |
assertEquals("a\\$b", makeRegexp("a$b")); |
176 |
assertEquals("a\\%b", RegexpMaker.makeRegexp("a%b")); |
178 |
assertEquals("a\\%b", makeRegexp("a%b")); |
177 |
assertEquals("a\\&b", RegexpMaker.makeRegexp("a&b")); |
179 |
assertEquals("a\\&b", makeRegexp("a&b")); |
178 |
assertEquals("a\\'b", RegexpMaker.makeRegexp("a'b")); |
180 |
assertEquals("a\\'b", makeRegexp("a'b")); |
179 |
assertEquals("a\\(b", RegexpMaker.makeRegexp("a(b")); |
181 |
assertEquals("a\\(b", makeRegexp("a(b")); |
180 |
assertEquals("a\\)b", RegexpMaker.makeRegexp("a)b")); |
182 |
assertEquals("a\\)b", makeRegexp("a)b")); |
181 |
assertEquals("a\\+b", RegexpMaker.makeRegexp("a+b")); |
183 |
assertEquals("a\\+b", makeRegexp("a+b")); |
182 |
assertEquals("a\\,b", RegexpMaker.makeRegexp("a,b")); |
184 |
assertEquals("a\\,b", makeRegexp("a,b")); |
183 |
assertEquals("a\\-b", RegexpMaker.makeRegexp("a-b")); |
185 |
assertEquals("a\\-b", makeRegexp("a-b")); |
184 |
assertEquals("a\\.b", RegexpMaker.makeRegexp("a.b")); |
186 |
assertEquals("a\\.b", makeRegexp("a.b")); |
185 |
assertEquals("a\\/b", RegexpMaker.makeRegexp("a/b")); |
187 |
assertEquals("a\\/b", makeRegexp("a/b")); |
186 |
|
188 |
|
187 |
assertEquals("a0b", RegexpMaker.makeRegexp("a0b")); |
189 |
assertEquals("a0b", makeRegexp("a0b")); |
188 |
assertEquals("a1b", RegexpMaker.makeRegexp("a1b")); |
190 |
assertEquals("a1b", makeRegexp("a1b")); |
189 |
assertEquals("a2b", RegexpMaker.makeRegexp("a2b")); |
191 |
assertEquals("a2b", makeRegexp("a2b")); |
190 |
assertEquals("a3b", RegexpMaker.makeRegexp("a3b")); |
192 |
assertEquals("a3b", makeRegexp("a3b")); |
191 |
assertEquals("a4b", RegexpMaker.makeRegexp("a4b")); |
193 |
assertEquals("a4b", makeRegexp("a4b")); |
192 |
assertEquals("a5b", RegexpMaker.makeRegexp("a5b")); |
194 |
assertEquals("a5b", makeRegexp("a5b")); |
193 |
assertEquals("a6b", RegexpMaker.makeRegexp("a6b")); |
195 |
assertEquals("a6b", makeRegexp("a6b")); |
194 |
assertEquals("a7b", RegexpMaker.makeRegexp("a7b")); |
196 |
assertEquals("a7b", makeRegexp("a7b")); |
195 |
assertEquals("a8b", RegexpMaker.makeRegexp("a8b")); |
197 |
assertEquals("a8b", makeRegexp("a8b")); |
196 |
assertEquals("a9b", RegexpMaker.makeRegexp("a9b")); |
198 |
assertEquals("a9b", makeRegexp("a9b")); |
197 |
|
199 |
|
198 |
assertEquals("a\\:b", RegexpMaker.makeRegexp("a:b")); |
200 |
assertEquals("a\\:b", makeRegexp("a:b")); |
199 |
assertEquals("a\\;b", RegexpMaker.makeRegexp("a;b")); |
201 |
assertEquals("a\\;b", makeRegexp("a;b")); |
200 |
assertEquals("a\\<b", RegexpMaker.makeRegexp("a<b")); |
202 |
assertEquals("a\\<b", makeRegexp("a<b")); |
201 |
assertEquals("a\\=b", RegexpMaker.makeRegexp("a=b")); |
203 |
assertEquals("a\\=b", makeRegexp("a=b")); |
202 |
assertEquals("a\\>b", RegexpMaker.makeRegexp("a>b")); |
204 |
assertEquals("a\\>b", makeRegexp("a>b")); |
203 |
assertEquals("a\\@b", RegexpMaker.makeRegexp("a@b")); |
205 |
assertEquals("a\\@b", makeRegexp("a@b")); |
204 |
assertEquals("a\\[b", RegexpMaker.makeRegexp("a[b")); |
206 |
assertEquals("a\\[b", makeRegexp("a[b")); |
205 |
assertEquals("a\\\\a", RegexpMaker.makeRegexp("a\\a")); |
207 |
assertEquals("a\\\\a", makeRegexp("a\\a")); |
206 |
assertEquals("a\\\\b", RegexpMaker.makeRegexp("a\\b")); |
208 |
assertEquals("a\\\\b", makeRegexp("a\\b")); |
207 |
assertEquals("a\\\\c", RegexpMaker.makeRegexp("a\\c")); |
209 |
assertEquals("a\\\\c", makeRegexp("a\\c")); |
208 |
assertEquals("a\\\\d", RegexpMaker.makeRegexp("a\\d")); |
210 |
assertEquals("a\\\\d", makeRegexp("a\\d")); |
209 |
assertEquals("a\\\\e", RegexpMaker.makeRegexp("a\\e")); |
211 |
assertEquals("a\\\\e", makeRegexp("a\\e")); |
210 |
assertEquals("a\\\\f", RegexpMaker.makeRegexp("a\\f")); |
212 |
assertEquals("a\\\\f", makeRegexp("a\\f")); |
211 |
assertEquals("a\\\\g", RegexpMaker.makeRegexp("a\\g")); |
213 |
assertEquals("a\\\\g", makeRegexp("a\\g")); |
212 |
assertEquals("a\\\\h", RegexpMaker.makeRegexp("a\\h")); |
214 |
assertEquals("a\\\\h", makeRegexp("a\\h")); |
213 |
assertEquals("a\\\\i", RegexpMaker.makeRegexp("a\\i")); |
215 |
assertEquals("a\\\\i", makeRegexp("a\\i")); |
214 |
assertEquals("a\\\\j", RegexpMaker.makeRegexp("a\\j")); |
216 |
assertEquals("a\\\\j", makeRegexp("a\\j")); |
215 |
assertEquals("a\\\\k", RegexpMaker.makeRegexp("a\\k")); |
217 |
assertEquals("a\\\\k", makeRegexp("a\\k")); |
216 |
assertEquals("a\\\\l", RegexpMaker.makeRegexp("a\\l")); |
218 |
assertEquals("a\\\\l", makeRegexp("a\\l")); |
217 |
assertEquals("a\\\\m", RegexpMaker.makeRegexp("a\\m")); |
219 |
assertEquals("a\\\\m", makeRegexp("a\\m")); |
218 |
assertEquals("a\\\\n", RegexpMaker.makeRegexp("a\\n")); |
220 |
assertEquals("a\\\\n", makeRegexp("a\\n")); |
219 |
assertEquals("a\\\\o", RegexpMaker.makeRegexp("a\\o")); |
221 |
assertEquals("a\\\\o", makeRegexp("a\\o")); |
220 |
assertEquals("a\\\\p", RegexpMaker.makeRegexp("a\\p")); |
222 |
assertEquals("a\\\\p", makeRegexp("a\\p")); |
221 |
assertEquals("a\\\\q", RegexpMaker.makeRegexp("a\\q")); |
223 |
assertEquals("a\\\\q", makeRegexp("a\\q")); |
222 |
assertEquals("a\\\\r", RegexpMaker.makeRegexp("a\\r")); |
224 |
assertEquals("a\\\\r", makeRegexp("a\\r")); |
223 |
assertEquals("a\\\\s", RegexpMaker.makeRegexp("a\\s")); |
225 |
assertEquals("a\\\\s", makeRegexp("a\\s")); |
224 |
assertEquals("a\\\\t", RegexpMaker.makeRegexp("a\\t")); |
226 |
assertEquals("a\\\\t", makeRegexp("a\\t")); |
225 |
assertEquals("a\\\\u", RegexpMaker.makeRegexp("a\\u")); |
227 |
assertEquals("a\\\\u", makeRegexp("a\\u")); |
226 |
assertEquals("a\\\\v", RegexpMaker.makeRegexp("a\\v")); |
228 |
assertEquals("a\\\\v", makeRegexp("a\\v")); |
227 |
assertEquals("a\\\\w", RegexpMaker.makeRegexp("a\\w")); |
229 |
assertEquals("a\\\\w", makeRegexp("a\\w")); |
228 |
assertEquals("a\\\\x", RegexpMaker.makeRegexp("a\\x")); |
230 |
assertEquals("a\\\\x", makeRegexp("a\\x")); |
229 |
assertEquals("a\\\\y", RegexpMaker.makeRegexp("a\\y")); |
231 |
assertEquals("a\\\\y", makeRegexp("a\\y")); |
230 |
assertEquals("a\\\\z", RegexpMaker.makeRegexp("a\\z")); |
232 |
assertEquals("a\\\\z", makeRegexp("a\\z")); |
231 |
assertEquals("a\\]b", RegexpMaker.makeRegexp("a]b")); |
233 |
assertEquals("a\\]b", makeRegexp("a]b")); |
232 |
assertEquals("a\\^b", RegexpMaker.makeRegexp("a^b")); |
234 |
assertEquals("a\\^b", makeRegexp("a^b")); |
233 |
assertEquals("a\\_b", RegexpMaker.makeRegexp("a_b")); |
235 |
assertEquals("a\\_b", makeRegexp("a_b")); |
234 |
assertEquals("a\\`b", RegexpMaker.makeRegexp("a`b")); |
236 |
assertEquals("a\\`b", makeRegexp("a`b")); |
235 |
assertEquals("a\\{b", RegexpMaker.makeRegexp("a{b")); |
237 |
assertEquals("a\\{b", makeRegexp("a{b")); |
236 |
assertEquals("a\\|b", RegexpMaker.makeRegexp("a|b")); |
238 |
assertEquals("a\\|b", makeRegexp("a|b")); |
237 |
assertEquals("a\\}b", RegexpMaker.makeRegexp("a}b")); |
239 |
assertEquals("a\\}b", makeRegexp("a}b")); |
238 |
assertEquals("a\\~b", RegexpMaker.makeRegexp("a~b")); |
240 |
assertEquals("a\\~b", makeRegexp("a~b")); |
239 |
assertEquals("a\\\u007fb", RegexpMaker.makeRegexp("a\u007fb")); |
241 |
assertEquals("a\\\u007fb", makeRegexp("a\u007fb")); |
240 |
|
242 |
|
241 |
assertEquals("a\u0080b", RegexpMaker.makeRegexp("a\u0080b")); |
243 |
assertEquals("a\u0080b", makeRegexp("a\u0080b")); |
242 |
assertEquals("a\u00c1b", RegexpMaker.makeRegexp("a\u00c1b")); |
244 |
assertEquals("a\u00c1b", makeRegexp("a\u00c1b")); |
243 |
|
245 |
|
244 |
assertEquals("abc\\\\", RegexpMaker.makeRegexp("abc\\")); |
246 |
assertEquals("abc\\\\", makeRegexp("abc\\")); |
245 |
assertEquals("\\\\\\\"", RegexpMaker.makeRegexp("\\\"")); |
247 |
assertEquals("\\\\\\\"", makeRegexp("\\\"")); |
246 |
assertEquals("\\\\", RegexpMaker.makeRegexp("\\")); |
248 |
assertEquals("\\\\", makeRegexp("\\")); |
247 |
assertEquals("\\<h3 style\\=\\\\\\\"color\\: green\\;\\\\\\\"\\>\\<\\/h3\\>", |
249 |
assertEquals("\\<h3 style\\=\\\\\\\"color\\: green\\;\\\\\\\"\\>\\<\\/h3\\>", |
248 |
RegexpMaker.makeRegexp("<h3 style=\\\"color: green;\\\"></h3>")); |
250 |
makeRegexp("<h3 style=\\\"color: green;\\\"></h3>")); |
249 |
|
251 |
|
250 |
} |
252 |
} |
251 |
|
253 |
|
Lines 300-306
Link Here
|
300 |
String simpleExpr, |
302 |
String simpleExpr, |
301 |
String expectedMatch, |
303 |
String expectedMatch, |
302 |
boolean wholeWords) { |
304 |
boolean wholeWords) { |
303 |
String regexp = RegexpMaker.makeRegexp(simpleExpr, wholeWords); |
305 |
String regexp = makeRegexp(simpleExpr, wholeWords); |
304 |
Matcher matcher = Pattern.compile(regexp).matcher(testString); |
306 |
Matcher matcher = Pattern.compile(regexp).matcher(testString); |
305 |
|
307 |
|
306 |
if (expectedMatch == null) { |
308 |
if (expectedMatch == null) { |
Lines 311-459
Link Here
|
311 |
} |
313 |
} |
312 |
} |
314 |
} |
313 |
|
315 |
|
314 |
public void testMakeMultiRegexp() { |
316 |
public void testCanBeMultilinePattern() { |
315 |
assertEquals("", RegexpMaker.makeMultiRegexp("")); |
317 |
assertFalse(TextRegexpUtil.canBeMultilinePattern("a\\d\\d\\da")); |
316 |
assertEquals("a", RegexpMaker.makeMultiRegexp("a")); |
318 |
assertFalse(TextRegexpUtil.canBeMultilinePattern(".*")); |
317 |
assertEquals("ab", RegexpMaker.makeMultiRegexp("ab")); |
319 |
assertFalse(TextRegexpUtil.canBeMultilinePattern("(?m)^x.*y$")); |
318 |
assertEquals("abc", RegexpMaker.makeMultiRegexp("abc")); |
320 |
assertTrue(TextRegexpUtil.canBeMultilinePattern("(?ms-x)test.*test")); |
319 |
assertEquals("a.", RegexpMaker.makeMultiRegexp("a?")); |
321 |
assertTrue(TextRegexpUtil.canBeMultilinePattern("test\\ntest")); |
320 |
assertEquals("a.*", RegexpMaker.makeMultiRegexp("a*")); |
322 |
assertTrue(TextRegexpUtil.canBeMultilinePattern("test\\rtest")); |
321 |
assertEquals(".a", RegexpMaker.makeMultiRegexp("?a")); |
323 |
assertTrue(TextRegexpUtil.canBeMultilinePattern("test\\r\\ntest")); |
322 |
assertEquals(".*a", RegexpMaker.makeMultiRegexp("*a")); |
324 |
assertTrue(TextRegexpUtil.canBeMultilinePattern("test\\ftest")); |
323 |
assertEquals("a.b", RegexpMaker.makeMultiRegexp("a?b")); |
325 |
assertTrue(TextRegexpUtil.canBeMultilinePattern("test\\u000Btest")); |
324 |
assertEquals(".a.", RegexpMaker.makeMultiRegexp("?a?")); |
326 |
assertTrue(TextRegexpUtil.canBeMultilinePattern("test\\x85test")); |
325 |
assertEquals("a.*b.c", RegexpMaker.makeMultiRegexp("a*b?c")); |
|
|
326 |
assertEquals("a...*b", RegexpMaker.makeMultiRegexp("a?*?b")); |
327 |
assertEquals("a..*b", RegexpMaker.makeMultiRegexp("a*?*b")); |
328 |
|
329 |
assertEquals("a|b", RegexpMaker.makeMultiRegexp("a b")); |
330 |
assertEquals("a\\!b", RegexpMaker.makeMultiRegexp("a!b")); |
331 |
assertEquals("a\\\"b", RegexpMaker.makeMultiRegexp("a\"b")); |
332 |
assertEquals("a\\#b", RegexpMaker.makeMultiRegexp("a#b")); |
333 |
assertEquals("a\\$b", RegexpMaker.makeMultiRegexp("a$b")); |
334 |
assertEquals("a\\%b", RegexpMaker.makeMultiRegexp("a%b")); |
335 |
assertEquals("a\\&b", RegexpMaker.makeMultiRegexp("a&b")); |
336 |
assertEquals("a\\'b", RegexpMaker.makeMultiRegexp("a'b")); |
337 |
assertEquals("a\\(b", RegexpMaker.makeMultiRegexp("a(b")); |
338 |
assertEquals("a\\)b", RegexpMaker.makeMultiRegexp("a)b")); |
339 |
assertEquals("a\\+b", RegexpMaker.makeMultiRegexp("a+b")); |
340 |
assertEquals("a|b", RegexpMaker.makeMultiRegexp("a,b")); |
341 |
assertEquals("a\\-b", RegexpMaker.makeMultiRegexp("a-b")); |
342 |
assertEquals("a\\.b", RegexpMaker.makeMultiRegexp("a.b")); |
343 |
assertEquals("a\\/b", RegexpMaker.makeMultiRegexp("a/b")); |
344 |
|
345 |
assertEquals("a0b", RegexpMaker.makeMultiRegexp("a0b")); |
346 |
assertEquals("a1b", RegexpMaker.makeMultiRegexp("a1b")); |
347 |
assertEquals("a2b", RegexpMaker.makeMultiRegexp("a2b")); |
348 |
assertEquals("a3b", RegexpMaker.makeMultiRegexp("a3b")); |
349 |
assertEquals("a4b", RegexpMaker.makeMultiRegexp("a4b")); |
350 |
assertEquals("a5b", RegexpMaker.makeMultiRegexp("a5b")); |
351 |
assertEquals("a6b", RegexpMaker.makeMultiRegexp("a6b")); |
352 |
assertEquals("a7b", RegexpMaker.makeMultiRegexp("a7b")); |
353 |
assertEquals("a8b", RegexpMaker.makeMultiRegexp("a8b")); |
354 |
assertEquals("a9b", RegexpMaker.makeMultiRegexp("a9b")); |
355 |
|
356 |
assertEquals("a\\:b", RegexpMaker.makeMultiRegexp("a:b")); |
357 |
assertEquals("a\\;b", RegexpMaker.makeMultiRegexp("a;b")); |
358 |
assertEquals("a\\<b", RegexpMaker.makeMultiRegexp("a<b")); |
359 |
assertEquals("a\\=b", RegexpMaker.makeMultiRegexp("a=b")); |
360 |
assertEquals("a\\>b", RegexpMaker.makeMultiRegexp("a>b")); |
361 |
assertEquals("a\\@b", RegexpMaker.makeMultiRegexp("a@b")); |
362 |
assertEquals("a\\[b", RegexpMaker.makeMultiRegexp("a[b")); |
363 |
assertEquals("ab", RegexpMaker.makeMultiRegexp("a\\b")); |
364 |
assertEquals("a\\]b", RegexpMaker.makeMultiRegexp("a]b")); |
365 |
assertEquals("a\\^b", RegexpMaker.makeMultiRegexp("a^b")); |
366 |
assertEquals("a\\_b", RegexpMaker.makeMultiRegexp("a_b")); |
367 |
assertEquals("a\\`b", RegexpMaker.makeMultiRegexp("a`b")); |
368 |
assertEquals("a\\{b", RegexpMaker.makeMultiRegexp("a{b")); |
369 |
assertEquals("a\\|b", RegexpMaker.makeMultiRegexp("a|b")); |
370 |
assertEquals("a\\}b", RegexpMaker.makeMultiRegexp("a}b")); |
371 |
assertEquals("a\\~b", RegexpMaker.makeMultiRegexp("a~b")); |
372 |
assertEquals("a\\\u007fb", RegexpMaker.makeMultiRegexp("a\u007fb")); |
373 |
|
374 |
assertEquals("a\u0080b", RegexpMaker.makeMultiRegexp("a\u0080b")); |
375 |
assertEquals("a\u00c1b", RegexpMaker.makeMultiRegexp("a\u00c1b")); |
376 |
|
377 |
assertEquals("abc\\\\", RegexpMaker.makeRegexp("abc\\")); |
378 |
|
379 |
assertEquals("", RegexpMaker.makeMultiRegexp("")); |
380 |
assertEquals("", RegexpMaker.makeMultiRegexp(" ")); |
381 |
assertEquals("", RegexpMaker.makeMultiRegexp(",")); |
382 |
assertEquals("", RegexpMaker.makeMultiRegexp(", ")); |
383 |
assertEquals("", RegexpMaker.makeMultiRegexp(" ,")); |
384 |
assertEquals("a", RegexpMaker.makeMultiRegexp("a,")); |
385 |
assertEquals("a", RegexpMaker.makeMultiRegexp("a ")); |
386 |
assertEquals("a", RegexpMaker.makeMultiRegexp("a, ")); |
387 |
assertEquals("a", RegexpMaker.makeMultiRegexp("a ,")); |
388 |
assertEquals("a", RegexpMaker.makeMultiRegexp(",a")); |
389 |
assertEquals("a", RegexpMaker.makeMultiRegexp(" a")); |
390 |
assertEquals("a", RegexpMaker.makeMultiRegexp(", a")); |
391 |
assertEquals("a", RegexpMaker.makeMultiRegexp(" ,a")); |
392 |
assertEquals("a|b", RegexpMaker.makeMultiRegexp("a b")); |
393 |
assertEquals("a|b", RegexpMaker.makeMultiRegexp("a,b")); |
394 |
assertEquals("a|b", RegexpMaker.makeMultiRegexp("a, b")); |
395 |
assertEquals("a|b", RegexpMaker.makeMultiRegexp("a ,b")); |
396 |
assertEquals(" ", RegexpMaker.makeMultiRegexp("\\ ")); |
397 |
assertEquals("\\,", RegexpMaker.makeMultiRegexp("\\,")); |
398 |
assertEquals("\\,", RegexpMaker.makeMultiRegexp("\\, ")); |
399 |
assertEquals(" ", RegexpMaker.makeMultiRegexp(",\\ ")); |
400 |
assertEquals("\\, ", RegexpMaker.makeMultiRegexp("\\,\\ ")); |
401 |
assertEquals(" ", RegexpMaker.makeMultiRegexp("\\ ,")); |
402 |
assertEquals("\\,", RegexpMaker.makeMultiRegexp(" \\,")); |
403 |
assertEquals(" \\,", RegexpMaker.makeMultiRegexp("\\ \\,")); |
404 |
assertEquals("a", RegexpMaker.makeMultiRegexp("\\a,")); |
405 |
assertEquals("a\\,", RegexpMaker.makeMultiRegexp("a\\,")); |
406 |
assertEquals("a\\,", RegexpMaker.makeMultiRegexp("\\a\\,")); |
407 |
assertEquals("a", RegexpMaker.makeMultiRegexp("\\a ")); |
408 |
assertEquals("a ", RegexpMaker.makeMultiRegexp("a\\ ")); |
409 |
assertEquals("a ", RegexpMaker.makeMultiRegexp("\\a\\ ")); |
410 |
assertEquals("a|\\\\", RegexpMaker.makeMultiRegexp("a, \\")); |
411 |
assertEquals("a| ", RegexpMaker.makeMultiRegexp("a,\\ ")); |
412 |
assertEquals("a| \\\\", RegexpMaker.makeMultiRegexp("a,\\ \\")); |
413 |
assertEquals("a\\,", RegexpMaker.makeMultiRegexp("a\\, ")); |
414 |
assertEquals("a\\,|\\\\", RegexpMaker.makeMultiRegexp("a\\, \\")); |
415 |
assertEquals("a\\, ", RegexpMaker.makeMultiRegexp("a\\,\\ ")); |
416 |
assertEquals("a\\, \\\\", RegexpMaker.makeMultiRegexp("a\\,\\ \\")); |
417 |
assertEquals("a", RegexpMaker.makeMultiRegexp("\\a, ")); |
418 |
assertEquals("a|\\\\", RegexpMaker.makeMultiRegexp("\\a, \\")); |
419 |
assertEquals("a| ", RegexpMaker.makeMultiRegexp("\\a,\\ ")); |
420 |
assertEquals("a| \\\\", RegexpMaker.makeMultiRegexp("\\a,\\ \\")); |
421 |
assertEquals("a\\,", RegexpMaker.makeMultiRegexp("\\a\\, ")); |
422 |
assertEquals("a\\,|\\\\", RegexpMaker.makeMultiRegexp("\\a\\, \\")); |
423 |
assertEquals("a\\, ", RegexpMaker.makeMultiRegexp("\\a\\,\\ ")); |
424 |
assertEquals("a\\, \\\\", RegexpMaker.makeMultiRegexp("\\a\\,\\ \\")); |
425 |
assertEquals("a|\\\\", RegexpMaker.makeMultiRegexp("a ,\\")); |
426 |
assertEquals("a|\\,", RegexpMaker.makeMultiRegexp("a \\,")); |
427 |
assertEquals("a|\\,\\\\", RegexpMaker.makeMultiRegexp("a \\,\\")); |
428 |
assertEquals("a ", RegexpMaker.makeMultiRegexp("a\\ ,")); |
429 |
assertEquals("a |\\\\", RegexpMaker.makeMultiRegexp("a\\ ,\\")); |
430 |
assertEquals("a \\,", RegexpMaker.makeMultiRegexp("a\\ \\,")); |
431 |
assertEquals("a \\,\\\\", RegexpMaker.makeMultiRegexp("a\\ \\,\\")); |
432 |
assertEquals("a", RegexpMaker.makeMultiRegexp("\\a ,")); |
433 |
assertEquals("a|\\\\", RegexpMaker.makeMultiRegexp("\\a ,\\")); |
434 |
assertEquals("a|\\,", RegexpMaker.makeMultiRegexp("\\a \\,")); |
435 |
assertEquals("a|\\,\\\\", RegexpMaker.makeMultiRegexp("\\a \\,\\")); |
436 |
assertEquals("a ", RegexpMaker.makeMultiRegexp("\\a\\ ,")); |
437 |
assertEquals("a |\\\\", RegexpMaker.makeMultiRegexp("\\a\\ ,\\")); |
438 |
assertEquals("a \\,", RegexpMaker.makeMultiRegexp("\\a\\ \\,")); |
439 |
assertEquals("a \\,\\\\", RegexpMaker.makeMultiRegexp("\\a\\ \\,\\")); |
440 |
|
441 |
assertEquals("a|b", RegexpMaker.makeMultiRegexp("a, b")); |
442 |
assertEquals("a|.*b.", RegexpMaker.makeMultiRegexp("a,*b?")); |
443 |
assertEquals("a|\\*b.", RegexpMaker.makeMultiRegexp("a,\\*b?")); |
444 |
assertEquals("a|.*b\\?", RegexpMaker.makeMultiRegexp("a,*b\\?")); |
445 |
} |
327 |
} |
446 |
|
328 |
|
447 |
public void testCanBeMultilinePattern() { |
329 |
public void testLiteralMatches() { |
448 |
assertFalse(RegexpMaker.canBeMultilinePattern("a\\d\\d\\da")); |
330 |
SearchPattern sp = SearchPattern.create("a*b", false, false, |
449 |
assertFalse(RegexpMaker.canBeMultilinePattern(".*")); |
331 |
MatchType.LITERAL); |
450 |
assertFalse(RegexpMaker.canBeMultilinePattern("(?m)^x.*y$")); |
332 |
Pattern p = TextRegexpUtil.makeTextPattern(sp); |
451 |
assertTrue(RegexpMaker.canBeMultilinePattern("(?ms-x)test.*test")); |
333 |
assertTrue(p.matcher("xxxa*byyy").find()); |
452 |
assertTrue(RegexpMaker.canBeMultilinePattern("test\\ntest")); |
334 |
assertFalse(p.matcher("xxxaSSbyyy").find()); |
453 |
assertTrue(RegexpMaker.canBeMultilinePattern("test\\rtest")); |
335 |
|
454 |
assertTrue(RegexpMaker.canBeMultilinePattern("test\\r\\ntest")); |
336 |
sp = sp.changeSearchExpression("a?b"); |
455 |
assertTrue(RegexpMaker.canBeMultilinePattern("test\\ftest")); |
337 |
p = TextRegexpUtil.makeTextPattern(sp); |
456 |
assertTrue(RegexpMaker.canBeMultilinePattern("test\\u000Btest")); |
338 |
assertTrue(p.matcher("xxxa?byyy").find()); |
457 |
assertTrue(RegexpMaker.canBeMultilinePattern("test\\x85test")); |
339 |
assertFalse(p.matcher("xxxaSbyyy").find()); |
|
|
340 |
|
341 |
sp = sp.changeSearchExpression("a?b*c*d?e"); |
342 |
p = TextRegexpUtil.makeTextPattern(sp); |
343 |
assertTrue(p.matcher("xxxa?b*c*d?eyyy").find()); |
344 |
assertFalse(p.matcher("xxxa?b*cudweyyy").find()); |
345 |
} |
346 |
|
347 |
private String makeRegexp(String string) { |
348 |
return TextRegexpUtil.makeTextPattern( |
349 |
SearchPattern.create(string, false, false, MatchType.BASIC)) |
350 |
.pattern(); |
351 |
} |
352 |
|
353 |
private String makeRegexp(String string, boolean wholeWords) { |
354 |
return TextRegexpUtil.makeTextPattern( |
355 |
SearchPattern.create( |
356 |
string, wholeWords, false, MatchType.BASIC)).pattern(); |
458 |
} |
357 |
} |
459 |
} |
358 |
} |