001/* $Id: ExtendedBaseRulesTestCase.java 1212599 2011-12-09 19:46:42Z simonetripodi $
002 *
003 * Licensed to the Apache Software Foundation (ASF) under one or more
004 * contributor license agreements.  See the NOTICE file distributed with
005 * this work for additional information regarding copyright ownership.
006 * The ASF licenses this file to You under the Apache License, Version 2.0
007 * (the "License"); you may not use this file except in compliance with
008 * the License.  You may obtain a copy of the License at
009 *
010 *      http://www.apache.org/licenses/LICENSE-2.0
011 *
012 * Unless required by applicable law or agreed to in writing, software
013 * distributed under the License is distributed on an "AS IS" BASIS,
014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
015 * See the License for the specific language governing permissions and
016 * limitations under the License.
017 */
018
019package org.apache.commons.digester3;
020
021import static org.junit.Assert.assertEquals;
022
023import java.util.Iterator;
024import java.util.List;
025
026import org.apache.commons.digester3.ExtendedBaseRules;
027import org.apache.commons.digester3.Rule;
028import org.apache.commons.digester3.Rules;
029import org.junit.Test;
030
031/**
032 * <p>
033 * Runs standard tests for RulesBase as well as tests of extensions.
034 *
035 * @author Robert Burrell Donkin <robertdonkin@mac.com>
036 */
037public class ExtendedBaseRulesTestCase
038    extends RulesBaseTestCase
039{
040
041    // -------------------------------------------------- Overall Test Methods
042
043    /**
044     * <p>
045     * This should be overriden by subclasses.
046     *
047     * @return the matching rules to be tested.
048     */
049    @Override
050    protected Rules createMatchingRulesForTest()
051    {
052
053        return new ExtendedBaseRules();
054    }
055
056    /**
057     * Basic test of parent matching rules. A parent match matches any child of a particular kind of parent. A wild
058     * parent has a wildcard prefix. This method tests non-universal wildcards.
059     */
060    @Test
061    public void testBasicParentMatch()
062    {
063
064        // clear any existing rules
065        digester.getRules().clear();
066
067        assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
068
069        // Set up rules
070        // since these are all NON-UNIVERSAL matches
071        // only expect one match at each stage
072        digester.addRule( "alpha/beta/gamma/delta", new TestRule( "exact" ) );
073        digester.addRule( "*/beta/gamma/epsilon", new TestRule( "wild_child" ) );
074        digester.addRule( "alpha/beta/gamma/?", new TestRule( "exact_parent" ) );
075        digester.addRule( "*/beta/gamma/?", new TestRule( "wild_parent" ) );
076
077        List<Rule> list = null;
078        Iterator<Rule> it = null;
079
080        // this should match just the exact since this has presidence
081        list = digester.getRules().match( null, "alpha/beta/gamma/delta", null, null );
082
083        // all three rules should match
084        assertEquals( "Testing basic parent mismatch (A)", 1, list.size() );
085
086        it = list.iterator();
087        assertEquals( "Testing basic parent mismatch (B)", "exact", ( (TestRule) it.next() ).getIdentifier() );
088
089        // we don't have an exact match for this child so we should get the exact parent
090        list = digester.getRules().match( null, "alpha/beta/gamma/epsilon", null, null );
091
092        // all three rules should match
093        assertEquals( "Testing basic parent mismatch (C)", 1, list.size() );
094
095        it = list.iterator();
096        assertEquals( "Testing basic parent mismatch (D)", "exact_parent", ( (TestRule) it.next() ).getIdentifier() );
097
098        // wild child overrides wild parent
099        list = digester.getRules().match( null, "alpha/omega/beta/gamma/epsilon", null, null );
100
101        // all three rules should match
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        // nothing else matches so return wild parent
108        list = digester.getRules().match( null, "alpha/omega/beta/gamma/zeta", null, null );
109
110        // all three rules should match
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        // clean up
117        digester.getRules().clear();
118
119    }
120
121    /**
122     * Basic test of universal matching rules. Universal rules act independent.
123     */
124    @Test
125    public void testBasicUniversal()
126    {
127
128        // clear any existing rules
129        digester.getRules().clear();
130
131        assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
132
133        // Set up rules
134        // set up universal matches against non-universal ones
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        // test universal wild head
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        // test universal parent
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        // test universal parent
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        // test wildcard universal parent
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        // test wildcard universal parent
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        // clean up
201        digester.getRules().clear();
202
203    }
204
205    /**
206     * Basic test of wild matches. A universal will match matches anything! A non-universal will match matches anything
207     * not matched by something else. This method tests non-universal and universal wild matches.
208     */
209    @Test
210    public void testWildMatch()
211    {
212
213        // clear any existing rules
214        digester.getRules().clear();
215
216        assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
217
218        // Set up rules
219        // The combinations a little large to test everything but we'll pick a couple and try them.
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        // The universal wild will always match whatever else does
229        list = digester.getRules().match( null, "alpha/beta/gamma/delta", null, null );
230
231        // all three rules should match
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        // The universal wild will always match whatever else does
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        // The universal wild will always match whatever else does
248        // we have no other non-universal matching so this will match the non-universal wild as well
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        // clean up
258        digester.getRules().clear();
259
260    }
261
262    /**
263     * Basic test of wild matches. A universal will match matches anything! A non-universal will match matches anything
264     * not matched by something else. This method tests non-universal and universal wild matches.
265     */
266    @Test
267    public void testRootTailMatch()
268    {
269
270        // clear any existing rules
271        digester.getRules().clear();
272
273        assertEquals( "Initial rules list is empty", 0, digester.getRules().rules().size() );
274
275        // Set up rules
276        // The combinations a little large to test everything but we'll pick a couple and try them.
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        // clean up
304        digester.getRules().clear();
305
306    }
307
308    @Test
309    public void testAncesterMatch()
310        throws Exception
311    {
312        // test fixed root ancester
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        // test wild root ancester
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}