2121import org .junit .Before ;
2222import org .junit .Test ;
2323
24+ import java .util .ArrayList ;
25+ import java .util .Arrays ;
26+ import java .util .Collections ;
27+ import java .util .List ;
28+
2429/**
2530 * Tests for class {@link WildcardTrie}
2631 *
2934 */
3035public final class WildcardTrieTest {
3136
37+ private static final String A = "a" ;
38+ private static final String AABB = "aabb" ;
39+ private static final String AACBB = "aacbb" ;
40+ private static final String AB = "ab" ;
41+ private static final String ABBC = "abbc" ;
3242 private static final String ABC = "abc" ;
43+ private static final String ACB = "acb" ;
44+ private static final String B = "b" ;
3345 private static final String CCB = "ccb" ;
46+ private static final String EMPTY = "" ;
47+ private static final String X = "x" ;
48+ private static final List <String > ALL = List .of (A , AABB , AACBB , AB , ABBC , ABC , ACB , B , CCB , EMPTY , X );
49+
3450 private static final String AAQBB = "aa?bb" ;
51+ private static final String AA_STAR_BB = "aa*bb" ;
52+ private static final String A_STAR = "a*" ;
3553 private static final String A_STAR_B = "a*b" ;
3654 private static final String A_STAR_BC = "a*bc" ;
37- private static final String AA_STAR_BB = "aa*bb" ;
3855 private static final String STAR_B = "*b" ;
39- private static final String A_STAR = "a*" ;
40- private static final String AACBB = "aacbb" ;
41- private static final String AABB = "aabb" ;
42- private static final String AB = "ab" ;
56+
4357 private static final String NOT_FOUND_BY = " not found by " ;
4458 private static final String FOUND_BY = " found by " ;
4559
@@ -54,121 +68,95 @@ public void createSystemUnderTest() {
5468 }
5569
5670 @ Test
57- public void testWithQWildcard () {
58- Assert .assertTrue (trie .get ("" ).isEmpty ());
59- Assert .assertTrue (trie .get ("x" ).isEmpty ());
60-
61- trie .put (ABC , ABC );
62- Assert .assertTrue (trie .get (ABC ).contains (ABC ));
63-
64- trie .put (AAQBB , AAQBB );
65- Assert .assertTrue (trie .get (AACBB ).contains (AAQBB ));
66- Assert .assertTrue (trie .get (AABB ).isEmpty ());
67-
68- trie .put (AABB , AABB );
69- Assert .assertTrue (trie .get (AABB ).contains (AABB ));
70- Assert .assertTrue (trie .get (AABB ).size () == 1 );
71+ public void testEmptyTrie () {
72+ assertTrie (null );
73+ }
7174
72- trie .put (AACBB , AACBB );
73- Assert .assertTrue (trie .get (AACBB ).contains (AACBB ));
74- Assert .assertTrue (trie .get (AACBB ).contains (AAQBB ));
75+ @ Test
76+ public void testWithQWildcard () {
77+ assertList (ABC , ABC );
78+ assertTrie (AAQBB , AACBB );
79+ assertList (AABB , AABB );
80+ assertList (AACBB , AAQBB , AACBB );
7581 }
7682
7783 @ Test
7884 public void testWithStarWildcard () {
79- trie .put (A_STAR_B , A_STAR_B );
80- Assert .assertTrue (AACBB + NOT_FOUND_BY + A_STAR_B , trie .get (AACBB ).contains (A_STAR_B ));
81- Assert .assertTrue (AABB + NOT_FOUND_BY + A_STAR_B , trie .get (AABB ).contains (A_STAR_B ));
82- Assert .assertTrue (AB + NOT_FOUND_BY + A_STAR_B , trie .get (AB ).contains (A_STAR_B ));
83- Assert .assertTrue (ABC + FOUND_BY + A_STAR_B , trie .get (ABC ).isEmpty ());
84- Assert .assertTrue (CCB + FOUND_BY + A_STAR_B , trie .get (CCB ).isEmpty ());
85-
86- trie .put (AABB , AABB );
87- Assert .assertTrue (trie .get (AABB ).contains (AABB ));
88- Assert .assertEquals (2 , trie .get (AABB ).size ());
89-
90- trie .put (AACBB , AACBB );
91- Assert .assertTrue (trie .get (AACBB ).contains (AACBB ));
92- Assert .assertTrue (trie .get (AACBB ).contains (A_STAR_B ));
85+ assertTrie (A_STAR_B , AABB , AACBB , AB , ACB );
86+ assertList (AABB , A_STAR_B , AABB );
87+ assertList (AACBB , A_STAR_B , AACBB );
9388 }
9489
9590 @ Test
9691 public void testWithTrailingStarWildcard () {
97- trie .put (A_STAR , A_STAR );
98- Assert .assertTrue (AACBB + NOT_FOUND_BY + A_STAR , trie .get (AACBB ).contains (A_STAR ));
99- Assert .assertTrue (AABB + NOT_FOUND_BY + A_STAR , trie .get (AABB ).contains (A_STAR ));
100- Assert .assertTrue (AB + NOT_FOUND_BY + A_STAR , trie .get (AB ).contains (A_STAR ));
101- Assert .assertTrue (ABC + NOT_FOUND_BY + A_STAR_B , trie .get (ABC ).contains (A_STAR ));
102- Assert .assertTrue (CCB + FOUND_BY + A_STAR_B , trie .get (CCB ).isEmpty ());
103-
104- trie .put (AABB , AABB );
105- Assert .assertTrue (trie .get (AABB ).contains (AABB ));
106- Assert .assertEquals (2 , trie .get (AABB ).size ());
107-
108- trie .put (AACBB , AACBB );
109- Assert .assertTrue (trie .get (AACBB ).contains (AACBB ));
110- Assert .assertTrue (trie .get (AACBB ).contains (A_STAR ));
92+ assertTrie (A_STAR , A , AABB , AACBB , AB , ABBC , ABC , ACB );
93+ assertList (AABB , A_STAR , AABB );
94+ assertList (AACBB , A_STAR , AACBB );
11195 }
11296
11397 @ Test
11498 public void testWithInitialStarWildcard () {
115- trie .put (STAR_B , STAR_B );
116- Assert .assertTrue (AACBB + NOT_FOUND_BY + STAR_B , trie .get (AACBB ).contains (STAR_B ));
117- Assert .assertTrue (AABB + NOT_FOUND_BY + STAR_B , trie .get (AABB ).contains (STAR_B ));
118-
119- Assert .assertTrue (ABC + FOUND_BY + A_STAR_B , trie .get (ABC ).isEmpty ());
120- Assert .assertTrue (CCB + NOT_FOUND_BY + A_STAR_B , trie .get (CCB ).contains (STAR_B ));
121-
122- trie .put (AABB , AABB );
123- Assert .assertTrue (trie .get (AABB ).contains (AABB ));
124- Assert .assertEquals (2 , trie .get (AABB ).size ());
125-
126- trie .put (AACBB , AACBB );
127- Assert .assertTrue (trie .get (AACBB ).contains (AACBB ));
128- Assert .assertTrue (trie .get (AACBB ).contains (STAR_B ));
99+ assertTrie (STAR_B , AABB , AACBB , AB , ACB , B , CCB );
100+ assertList (AABB , STAR_B , AABB );
101+ assertList (AACBB , STAR_B , AACBB );
129102 }
130103
131104 @ Test
132105 public void testWithMultipleStarWildcards () {
133- trie .put (STAR_B , STAR_B );
134- trie .put (A_STAR , A_STAR );
135- trie .put (A_STAR_B , A_STAR_B );
136-
137- Assert .assertEquals (3 , trie .get (AACBB ).size ());
106+ assertTrie (STAR_B , AABB , AACBB , AB , ACB , B , CCB );
107+ assertTrie (A_STAR , A , AABB , AACBB , AB , ABC , ABBC , ACB );
108+ assertTrie (A_STAR_B , AABB , AACBB , AB , ACB );
109+ assertList (AACBB , STAR_B , A_STAR , A_STAR_B , AACBB );
138110
139- trie . put (AA_STAR_BB , AA_STAR_BB );
140- Assert . assertEquals ( 4 , trie . get ( AACBB ). size () );
111+ assertTrie (AA_STAR_BB , AABB , AACBB );
112+ assertList ( AACBB , STAR_B , A_STAR , A_STAR_B , AA_STAR_BB , AACBB );
141113
142- Assert .assertEquals (3 , trie .get (AB ).size ());
143- Assert .assertEquals (1 , trie .get (CCB ).size ());
144-
145- Assert .assertEquals (3 , trie .get ("acb" ).size ());
114+ assertList (AB , STAR_B , A_STAR , A_STAR_B , AB );
115+ assertList (ACB , STAR_B , A_STAR , A_STAR_B , ACB );
116+ assertList (CCB , STAR_B , CCB );
146117 }
147118
148119 @ Test
149120 public void testOverlapWithWildcard () {
150- trie .put (ABC , ABC );
151- trie .put (A_STAR_BC , A_STAR_BC );
152-
153- Assert .assertEquals (2 , trie .get (ABC ).size ());
154- Assert .assertEquals (1 , trie .get ("abbc" ).size ());
121+ assertTrie (A_STAR_BC , ABBC , ABC );
122+ assertList (ABC , A_STAR_BC , ABC );
123+ assertList (ABBC , A_STAR_BC , ABBC );
155124 }
156125
157126 @ Test
158127 public void testEmptyKey () {
159- trie .put ("" , ABC );
160- Assert .assertEquals (1 , trie .get ("" ).size ());
128+ assertList (EMPTY , EMPTY );
161129 }
162130
163131 @ Test
164132 public void testWithOrAndWildcard () {
165- final String key = ABC + WildcardTrie .OR_STRING + CCB ;
166- trie .put (key , "" );
167- Assert .assertTrue (ABC + NOT_FOUND_BY + key , trie .get (ABC ).contains ("" ));
168- Assert .assertTrue (CCB + NOT_FOUND_BY + key , trie .get (CCB ).contains ("" ));
133+ assertTrie (ABC + WildcardTrie .OR_STRING + CCB , ABC , CCB );
134+ }
135+
136+ private void assertTrie (final String key , final String ... positive ) {
137+ final List <String > negative = new ArrayList <>(ALL );
138+
139+ if (key != null ) {
140+ trie .put (key , key );
141+ }
142+
143+ Arrays .stream (positive ).forEach (k -> {
144+ negative .remove (k );
145+ Assert .assertTrue (k + NOT_FOUND_BY + key , trie .get (k ).contains (key ));
146+ });
147+
148+ negative .forEach (k -> {
149+ Assert .assertFalse (k + FOUND_BY + key , trie .get (k ).contains (key ));
150+ });
151+ }
152+
153+ private void assertList (final String key , final String ... expected ) {
154+ assertTrie (key , key );
155+
156+ final List <String > actual = trie .get (key );
157+ Collections .sort (actual );
169158
170- Assert .assertTrue (AABB + FOUND_BY + key , trie .get (AABB ).isEmpty ());
171- Assert .assertTrue (AB + FOUND_BY + key , trie .get (AB ).isEmpty ());
159+ Assert .assertEquals (Arrays .asList (expected ), actual );
172160 }
173161
174162}
0 commit comments