Skip to content

Commit 090d344

Browse files
blackwinterblackwinter
committed
Extend WildcardTrieTest with more exhaustive assertions.
- `assertTrie` ensures that both positive _and_ negative matches are verified. - `assertList` ensures furthermore that exactly the expected matches are returned.
1 parent 16a41b0 commit 090d344

File tree

1 file changed

+74
-88
lines changed

1 file changed

+74
-88
lines changed

‎metafacture-commons/src/test/java/org/metafacture/commons/tries/WildcardTrieTest.java‎

Lines changed: 74 additions & 88 deletions
Original file line numberDiff line numberDiff line change
@@ -21,6 +21,11 @@
2121
import org.junit.Before;
2222
import 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
*
@@ -29,17 +34,24 @@
2934
*/
3035
public final class WildcardTrieTest {
3136

37+
private static final String AABB = "aabb";
38+
private static final String AACBB = "aacbb";
39+
private static final String AB = "ab";
40+
private static final String ABBC = "abbc";
3241
private static final String ABC = "abc";
42+
private static final String ACB = "acb";
3343
private static final String CCB = "ccb";
44+
private static final String EMPTY = "";
45+
private static final String X = "x";
46+
private static final List<String> ALL = List.of(AABB, AACBB, AB, ABBC, ABC, ACB, CCB, EMPTY, X);
47+
3448
private static final String AAQBB = "aa?bb";
49+
private static final String AA_STAR_BB = "aa*bb";
50+
private static final String A_STAR = "a*";
3551
private static final String A_STAR_B = "a*b";
3652
private static final String A_STAR_BC = "a*bc";
37-
private static final String AA_STAR_BB = "aa*bb";
3853
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";
54+
4355
private static final String NOT_FOUND_BY = " not found by ";
4456
private static final String FOUND_BY = " found by ";
4557

@@ -54,121 +66,95 @@ public void createSystemUnderTest() {
5466
}
5567

5668
@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);
69+
public void testEmptyTrie() {
70+
assertTrie(null);
71+
}
7172

72-
trie.put(AACBB, AACBB);
73-
Assert.assertTrue(trie.get(AACBB).contains(AACBB));
74-
Assert.assertTrue(trie.get(AACBB).contains(AAQBB));
73+
@Test
74+
public void testWithQWildcard() {
75+
assertList(ABC, ABC);
76+
assertTrie(AAQBB, AACBB);
77+
assertList(AABB, AABB);
78+
assertList(AACBB, AAQBB, AACBB);
7579
}
7680

7781
@Test
7882
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));
83+
assertTrie(A_STAR_B, AABB, AACBB, AB, ACB);
84+
assertList(AABB, A_STAR_B, AABB);
85+
assertList(AACBB, A_STAR_B, AACBB);
9386
}
9487

9588
@Test
9689
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));
90+
assertTrie(A_STAR, AABB, AACBB, AB, ABBC, ABC, ACB);
91+
assertList(AABB, A_STAR, AABB);
92+
assertList(AACBB, A_STAR, AACBB);
11193
}
11294

11395
@Test
11496
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));
97+
assertTrie(STAR_B, AABB, AACBB, AB, ACB, CCB);
98+
assertList(AABB, STAR_B, AABB);
99+
assertList(AACBB, STAR_B, AACBB);
129100
}
130101

131102
@Test
132103
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());
104+
assertTrie(STAR_B, AABB, AACBB, AB, ACB, CCB);
105+
assertTrie(A_STAR, AABB, AACBB, AB, ABC, ABBC, ACB);
106+
assertTrie(A_STAR_B, AABB, AACBB, AB, ACB);
107+
assertList(AACBB, STAR_B, A_STAR, A_STAR_B, AACBB);
138108

139-
trie.put(AA_STAR_BB, AA_STAR_BB);
140-
Assert.assertEquals(4, trie.get(AACBB).size());
109+
assertTrie(AA_STAR_BB, AABB, AACBB);
110+
assertList(AACBB, STAR_B, A_STAR, A_STAR_B, AA_STAR_BB, AACBB);
141111

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());
112+
assertList(AB, STAR_B, A_STAR, A_STAR_B, AB);
113+
assertList(ACB, STAR_B, A_STAR, A_STAR_B, ACB);
114+
assertList(CCB, STAR_B, CCB);
146115
}
147116

148117
@Test
149118
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());
119+
assertTrie(A_STAR_BC, ABBC, ABC);
120+
assertList(ABC, A_STAR_BC, ABC);
121+
assertList(ABBC, A_STAR_BC, ABBC);
155122
}
156123

157124
@Test
158125
public void testEmptyKey() {
159-
trie.put("", ABC);
160-
Assert.assertEquals(1, trie.get("").size());
126+
assertList(EMPTY, EMPTY);
161127
}
162128

163129
@Test
164130
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(""));
131+
assertTrie(ABC + WildcardTrie.OR_STRING + CCB, ABC, CCB);
132+
}
133+
134+
private void assertTrie(final String key, final String... positive) {
135+
final List<String> negative = new ArrayList<>(ALL);
136+
137+
if (key != null) {
138+
trie.put(key, key);
139+
}
140+
141+
Arrays.stream(positive).forEach(k -> {
142+
negative.remove(k);
143+
Assert.assertTrue(k + NOT_FOUND_BY + key, trie.get(k).contains(key));
144+
});
145+
146+
negative.forEach(k -> {
147+
Assert.assertFalse(k + FOUND_BY + key, trie.get(k).contains(key));
148+
});
149+
}
150+
151+
private void assertList(final String key, final String... expected) {
152+
assertTrie(key, key);
153+
154+
final List<String> actual = trie.get(key);
155+
Collections.sort(actual);
169156

170-
Assert.assertTrue(AABB + FOUND_BY + key, trie.get(AABB).isEmpty());
171-
Assert.assertTrue(AB + FOUND_BY + key, trie.get(AB).isEmpty());
157+
Assert.assertEquals(Arrays.asList(expected), actual);
172158
}
173159

174160
}

0 commit comments

Comments
 (0)