1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.commons.digester3;
20
21 import static org.junit.Assert.assertEquals;
22
23 import java.util.Iterator;
24 import java.util.List;
25
26 import org.apache.commons.digester3.ExtendedBaseRules;
27 import org.apache.commons.digester3.Rule;
28 import org.apache.commons.digester3.Rules;
29 import org.junit.Test;
30
31
32
33
34
35
36
37 public class ExtendedBaseRulesTestCase
38 extends RulesBaseTestCase
39 {
40
41
42
43
44
45
46
47
48
49 @Override
50 protected Rules createMatchingRulesForTest()
51 {
52
53 return new ExtendedBaseRules();
54 }
55
56
57
58
59
60 @Test
61 public void testBasicParentMatch()
62 {
63
64
65 digester.getRules().clear();
66
67 assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
68
69
70
71
72 digester.addRule( "alpha/beta/gamma/delta", new TestRule( "exact" ) );
73 digester.addRule( "*/beta/gamma/epsilon", new TestRule( "wild_child" ) );
74 digester.addRule( "alpha/beta/gamma/?", new TestRule( "exact_parent" ) );
75 digester.addRule( "*/beta/gamma/?", new TestRule( "wild_parent" ) );
76
77 List<Rule> list = null;
78 Iterator<Rule> it = null;
79
80
81 list = digester.getRules().match( null, "alpha/beta/gamma/delta", null, null );
82
83
84 assertEquals( "Testing basic parent mismatch (A)", 1, list.size() );
85
86 it = list.iterator();
87 assertEquals( "Testing basic parent mismatch (B)", "exact", ( (TestRule) it.next() ).getIdentifier() );
88
89
90 list = digester.getRules().match( null, "alpha/beta/gamma/epsilon", null, null );
91
92
93 assertEquals( "Testing basic parent mismatch (C)", 1, list.size() );
94
95 it = list.iterator();
96 assertEquals( "Testing basic parent mismatch (D)", "exact_parent", ( (TestRule) it.next() ).getIdentifier() );
97
98
99 list = digester.getRules().match( null, "alpha/omega/beta/gamma/epsilon", null, null );
100
101
102 assertEquals( "Testing basic parent mismatch (E)", 1, list.size() );
103
104 it = list.iterator();
105 assertEquals( "Testing basic parent mismatch (F)", "wild_child", ( (TestRule) it.next() ).getIdentifier() );
106
107
108 list = digester.getRules().match( null, "alpha/omega/beta/gamma/zeta", null, null );
109
110
111 assertEquals( "Testing basic parent mismatch (G)", 1, list.size() );
112
113 it = list.iterator();
114 assertEquals( "Testing basic parent mismatch (H)", "wild_parent", ( (TestRule) it.next() ).getIdentifier() );
115
116
117 digester.getRules().clear();
118
119 }
120
121
122
123
124 @Test
125 public void testBasicUniversal()
126 {
127
128
129 digester.getRules().clear();
130
131 assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
132
133
134
135 digester.addRule( "alpha/beta/gamma", new TestRule( "exact" ) );
136 digester.addRule( "*/beta/gamma", new TestRule( "non_wild_head" ) );
137 digester.addRule( "!*/beta/gamma", new TestRule( "universal_wild_head" ) );
138 digester.addRule( "!alpha/beta/gamma/?", new TestRule( "universal_wild_child" ) );
139 digester.addRule( "alpha/beta/gamma/?", new TestRule( "non_wild_child" ) );
140 digester.addRule( "alpha/beta/gamma/epsilon", new TestRule( "exact2" ) );
141 digester.addRule( "alpha/epsilon/beta/gamma/zeta", new TestRule( "exact3" ) );
142 digester.addRule( "*/gamma/?", new TestRule( "non_wildhead_child" ) );
143 digester.addRule( "!*/epsilon/beta/gamma/?", new TestRule( "universal_wildhead_child" ) );
144
145 List<Rule> list = null;
146 Iterator<Rule> it = null;
147
148
149 list = digester.getRules().match( null, "alpha/beta/gamma", null, null );
150
151 assertEquals( "Testing universal wildcard mismatch (A)", 2, list.size() );
152
153 it = list.iterator();
154 assertEquals( "Testing universal wildcard mismatch (B)", "exact", ( (TestRule) it.next() ).getIdentifier() );
155 assertEquals( "Testing universal wildcard mismatch (C)", "universal_wild_head",
156 ( (TestRule) it.next() ).getIdentifier() );
157
158
159 list = digester.getRules().match( null, "alpha/beta/gamma/epsilon", null, null );
160
161 assertEquals( "Testing universal wildcard mismatch (D)", 2, list.size() );
162
163 it = list.iterator();
164 assertEquals( "Testing universal wildcard mismatch (E)", "universal_wild_child",
165 ( (TestRule) it.next() ).getIdentifier() );
166 assertEquals( "Testing universal wildcard mismatch (F)", "exact2", ( (TestRule) it.next() ).getIdentifier() );
167
168
169 list = digester.getRules().match( null, "alpha/beta/gamma/zeta", null, null );
170
171 assertEquals( "Testing universal wildcard mismatch (G)", 2, list.size() );
172
173 it = list.iterator();
174 assertEquals( "Testing universal wildcard mismatch (H)", "universal_wild_child",
175 ( (TestRule) it.next() ).getIdentifier() );
176 assertEquals( "Testing universal wildcard mismatch (I)", "non_wild_child",
177 ( (TestRule) it.next() ).getIdentifier() );
178
179
180 list = digester.getRules().match( null, "alpha/epsilon/beta/gamma/alpha", null, null );
181
182 assertEquals( "Testing universal wildcard mismatch (J)", 2, list.size() );
183
184 it = list.iterator();
185 assertEquals( "Testing universal wildcard mismatch (K)", "non_wildhead_child",
186 ( (TestRule) it.next() ).getIdentifier() );
187 assertEquals( "Testing universal wildcard mismatch (L)", "universal_wildhead_child",
188 ( (TestRule) it.next() ).getIdentifier() );
189
190
191 list = digester.getRules().match( null, "alpha/epsilon/beta/gamma/zeta", null, null );
192
193 assertEquals( "Testing universal wildcard mismatch (M)", 2, list.size() );
194
195 it = list.iterator();
196 assertEquals( "Testing universal wildcard mismatch (M)", "exact3", ( (TestRule) it.next() ).getIdentifier() );
197 assertEquals( "Testing universal wildcard mismatch (O)", "universal_wildhead_child",
198 ( (TestRule) it.next() ).getIdentifier() );
199
200
201 digester.getRules().clear();
202
203 }
204
205
206
207
208
209 @Test
210 public void testWildMatch()
211 {
212
213
214 digester.getRules().clear();
215
216 assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
217
218
219
220 digester.addRule( "*", new TestRule( "basic_wild" ) );
221 digester.addRule( "!*", new TestRule( "universal_wild" ) );
222 digester.addRule( "alpha/beta/gamma/delta", new TestRule( "exact" ) );
223 digester.addRule( "*/beta/gamma/?", new TestRule( "wild_parent" ) );
224
225 List<Rule> list = null;
226 Iterator<Rule> it = null;
227
228
229 list = digester.getRules().match( null, "alpha/beta/gamma/delta", null, null );
230
231
232 assertEquals( "Testing wild mismatch (A)", 2, list.size() );
233
234 it = list.iterator();
235 assertEquals( "Testing wild mismatch (B)", "universal_wild", ( (TestRule) it.next() ).getIdentifier() );
236 assertEquals( "Testing wild mismatch (C)", "exact", ( (TestRule) it.next() ).getIdentifier() );
237
238
239 list = digester.getRules().match( null, "alpha/beta/gamma/epsilon", null, null );
240
241 assertEquals( "Testing wild mismatch (D)", 2, list.size() );
242
243 it = list.iterator();
244 assertEquals( "Testing wild mismatch (E)", "universal_wild", ( (TestRule) it.next() ).getIdentifier() );
245 assertEquals( "Testing wild mismatch (F)", "wild_parent", ( (TestRule) it.next() ).getIdentifier() );
246
247
248
249 list = digester.getRules().match( null, "alpha/gamma", null, null );
250
251 assertEquals( "Testing wild mismatch (G)", 2, list.size() );
252
253 it = list.iterator();
254 assertEquals( "Testing wild mismatch (H)", "basic_wild", ( (TestRule) it.next() ).getIdentifier() );
255 assertEquals( "Testing wild mismatch (I)", "universal_wild", ( (TestRule) it.next() ).getIdentifier() );
256
257
258 digester.getRules().clear();
259
260 }
261
262
263
264
265
266 @Test
267 public void testRootTailMatch()
268 {
269
270
271 digester.getRules().clear();
272
273 assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
274
275
276
277 digester.addRule( "*/a", new TestRule( "a_tail" ) );
278
279 List<Rule> list = null;
280
281 list = digester.getRules().match( null, "a", null, null );
282
283 assertEquals( "Testing tail wrong size (A)", 1, list.size() );
284 assertEquals( "Testing tail mismatch (B)", "a_tail", ( (TestRule) list.get( 0 ) ).getIdentifier() );
285
286 list = digester.getRules().match( null, "beta/a", null, null );
287
288 assertEquals( "Testing tail wrong size (C)", 1, list.size() );
289 assertEquals( "Testing tail mismatch (D)", "a_tail", ( (TestRule) list.get( 0 ) ).getIdentifier() );
290
291 list = digester.getRules().match( null, "be/aaa", null, null );
292
293 assertEquals( "Testing tail no matches (E)", 0, list.size() );
294
295 list = digester.getRules().match( null, "aaa", null, null );
296
297 assertEquals( "Testing tail no matches (F)", 0, list.size() );
298
299 list = digester.getRules().match( null, "a/beta", null, null );
300
301 assertEquals( "Testing tail no matches (G)", 0, list.size() );
302
303
304 digester.getRules().clear();
305
306 }
307
308 @Test
309 public void testAncesterMatch()
310 throws Exception
311 {
312
313 digester.getRules().clear();
314
315 digester.addRule( "!a/b/*", new TestRule( "uni-a-b-star" ) );
316 digester.addRule( "a/b/*", new TestRule( "a-b-star" ) );
317 digester.addRule( "a/b/c", new TestRule( "a-b-c" ) );
318 digester.addRule( "a/b/?", new TestRule( "a-b-child" ) );
319
320 List<Rule> list = digester.getRules().match( null, "a/b/c", null, null );
321
322 assertEquals( "Simple ancester matches (1)", 2, list.size() );
323 assertEquals( "Univeral ancester mismatch (1)", "uni-a-b-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
324 assertEquals( "Parent precedence failure", "a-b-c", ( (TestRule) list.get( 1 ) ).getIdentifier() );
325
326 list = digester.getRules().match( null, "a/b/b", null, null );
327 assertEquals( "Simple ancester matches (2)", 2, list.size() );
328 assertEquals( "Univeral ancester mismatch (2)", "uni-a-b-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
329 assertEquals( "Child precedence failure", "a-b-child", ( (TestRule) list.get( 1 ) ).getIdentifier() );
330
331 list = digester.getRules().match( null, "a/b/d", null, null );
332 assertEquals( "Simple ancester matches (3)", 2, list.size() );
333 assertEquals( "Univeral ancester mismatch (3)", "uni-a-b-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
334 assertEquals( "Ancester mismatch (1)", "a-b-child", ( (TestRule) list.get( 1 ) ).getIdentifier() );
335
336 list = digester.getRules().match( null, "a/b/d/e/f", null, null );
337 assertEquals( "Simple ancester matches (4)", 2, list.size() );
338 assertEquals( "Univeral ancester mismatch (4)", "uni-a-b-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
339 assertEquals( "Ancester mismatch (2)", "a-b-star", ( (TestRule) list.get( 1 ) ).getIdentifier() );
340
341
342 digester.getRules().clear();
343
344 digester.addRule( "!*/a/b/*", new TestRule( "uni-star-a-b-star" ) );
345 digester.addRule( "*/b/c/*", new TestRule( "star-b-c-star" ) );
346 digester.addRule( "*/b/c/d", new TestRule( "star-b-c-d" ) );
347 digester.addRule( "a/b/c", new TestRule( "a-b-c" ) );
348
349 list = digester.getRules().match( null, "a/b/c", null, null );
350 assertEquals( "Wild ancester match (1)", 2, list.size() );
351 assertEquals( "Univeral ancester mismatch (5)", "uni-star-a-b-star",
352 ( (TestRule) list.get( 0 ) ).getIdentifier() );
353 assertEquals( "Match missed (1)", "a-b-c", ( (TestRule) list.get( 1 ) ).getIdentifier() );
354
355 list = digester.getRules().match( null, "b/c", null, null );
356 assertEquals( "Wild ancester match (2)", 1, list.size() );
357 assertEquals( "Match missed (2)", "star-b-c-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
358
359 list = digester.getRules().match( null, "a/b/c/d", null, null );
360 assertEquals( "Wild ancester match (3)", 2, list.size() );
361 assertEquals( "Match missed (3)", "uni-star-a-b-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
362 assertEquals( "Match missed (4)", "star-b-c-d", ( (TestRule) list.get( 1 ) ).getIdentifier() );
363
364 list = digester.getRules().match( null, "b/b/c/e/d", null, null );
365 assertEquals( "Wild ancester match (2)", 1, list.size() );
366 assertEquals( "Match missed (5)", "star-b-c-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
367 }
368
369 @Test
370 public void testLongMatch()
371 {
372
373 digester.getRules().clear();
374
375 digester.addRule( "a/b/c/d/*", new TestRule( "a-b-c-d-star" ) );
376
377 List<Rule> list = digester.getRules().match( null, "a/b/c/d/e", null, null );
378 assertEquals( "Long match (1)", 1, list.size() );
379 assertEquals( "Match missed (1)", "a-b-c-d-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
380
381 list = digester.getRules().match( null, "a/b/c/d/e/f", null, null );
382 assertEquals( "Long match (2)", 1, list.size() );
383 assertEquals( "Match missed (2)", "a-b-c-d-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
384
385 list = digester.getRules().match( null, "a/b/c/d/e/f/g", null, null );
386 assertEquals( "Long match (3)", 1, list.size() );
387 assertEquals( "Match missed (3)", "a-b-c-d-star", ( (TestRule) list.get( 0 ) ).getIdentifier() );
388
389 list = digester.getRules().match( null, "a/b/c/d", null, null );
390 assertEquals( "Long match (4)", 0, list.size() );
391 }
392
393 @Test
394 public void testInstructors()
395 {
396 digester.getRules().clear();
397
398 digester.addRule( "!instructors/*", new TestRule( "instructors" ) );
399 digester.addRule( "!instructor/*", new TestRule( "instructor" ) );
400
401 List<Rule> list = digester.getRules().match( null, "instructors", null, null );
402 assertEquals( "Only expect to match instructors", 1, list.size() );
403 assertEquals( "Instructors expected", "instructors", ( (TestRule) list.get( 0 ) ).getIdentifier() );
404
405 }
406
407 @Test
408 public void testMiddleInstructors()
409 {
410 digester.getRules().clear();
411
412 digester.addRule( "!instructors/*", new TestRule( "instructors" ) );
413
414 List<Rule> list = digester.getRules().match( null, "/tosh/instructors/fiddlesticks", null, null );
415 assertEquals( "No matches expected", 0, list.size() );
416
417 }
418 }