1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
package org.qedeq.kernel.se.dto.list; |
17 |
|
|
18 |
|
import java.util.Iterator; |
19 |
|
import java.util.List; |
20 |
|
|
21 |
|
import org.qedeq.base.test.QedeqTestCase; |
22 |
|
import org.qedeq.kernel.se.base.list.Atom; |
23 |
|
import org.qedeq.kernel.se.base.list.Element; |
24 |
|
import org.qedeq.kernel.se.base.list.ElementList; |
25 |
|
|
26 |
|
|
27 |
|
|
28 |
|
|
29 |
|
@author |
30 |
|
|
|
|
| 82% |
Uncovered Elements: 37 (205) |
Complexity: 46 |
Complexity Density: 0.27 |
|
31 |
|
public class ElementSetTest extends QedeqTestCase { |
32 |
|
|
33 |
|
|
34 |
|
private ElementSet empty; |
35 |
|
|
36 |
|
|
37 |
|
private ElementSet one; |
38 |
|
|
39 |
|
|
40 |
|
private ElementSet two; |
41 |
|
|
42 |
|
|
43 |
|
private ElementSet two2; |
44 |
|
|
45 |
|
|
46 |
|
private ElementSet oneTwo; |
47 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
48 |
0
|
public ElementSetTest(){... |
49 |
0
|
super(); |
50 |
|
} |
51 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
52 |
14
|
public ElementSetTest(final String name){... |
53 |
14
|
super(name); |
54 |
|
} |
55 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
56 |
14
|
protected void setUp() throws Exception {... |
57 |
14
|
super.setUp(); |
58 |
14
|
initAttributes(); |
59 |
|
} |
60 |
|
|
61 |
|
|
62 |
|
|
63 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
|
64 |
17
|
private void initAttributes() {... |
65 |
17
|
empty = new ElementSet(); |
66 |
17
|
one = new ElementSet(new Element[] {new DefaultAtom("one")}); |
67 |
17
|
two = new ElementSet(new Element[] {new DefaultAtom("two")}); |
68 |
17
|
two2 = new ElementSet(); |
69 |
17
|
two2.add(new DefaultAtom("two")); |
70 |
17
|
oneTwo = new ElementSet(); |
71 |
17
|
oneTwo.add(new DefaultAtom("one")); |
72 |
17
|
oneTwo.add(new DefaultAtom("two")); |
73 |
|
} |
74 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
|
75 |
14
|
protected void tearDown() throws Exception {... |
76 |
14
|
empty = null; |
77 |
14
|
one = null; |
78 |
14
|
two = null; |
79 |
14
|
two2 = null; |
80 |
14
|
oneTwo = null; |
81 |
14
|
super.tearDown(); |
82 |
|
} |
83 |
|
|
84 |
|
|
85 |
|
|
86 |
|
|
87 |
|
|
|
|
| 71.4% |
Uncovered Elements: 4 (14) |
Complexity: 5 |
Complexity Density: 0.36 |
1
PASS
|
|
88 |
1
|
public void testConstructor() {... |
89 |
1
|
try { |
90 |
1
|
new ElementSet((Element []) null); |
91 |
0
|
fail("Exception expected"); |
92 |
|
} catch (Exception e) { |
93 |
|
|
94 |
|
} |
95 |
1
|
try { |
96 |
1
|
new ElementSet((ElementSet) null); |
97 |
0
|
fail("Exception expected"); |
98 |
|
} catch (Exception e) { |
99 |
|
|
100 |
|
} |
101 |
1
|
try { |
102 |
1
|
new ElementSet((ElementList) null); |
103 |
0
|
fail("Exception expected"); |
104 |
|
} catch (Exception e) { |
105 |
|
|
106 |
|
} |
107 |
1
|
try { |
108 |
1
|
new ElementSet(new ElementList() { |
|
|
| - |
Uncovered Elements: 0 (0) |
Complexity: 1 |
Complexity Density: - |
|
109 |
0
|
public void add(Element element) {... |
110 |
|
} |
111 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
112 |
0
|
public Element getElement(int i) {... |
113 |
0
|
return null; |
114 |
|
} |
115 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
116 |
0
|
public List getElements() {... |
117 |
0
|
return null; |
118 |
|
} |
119 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
120 |
0
|
public String getOperator() {... |
121 |
0
|
return null; |
122 |
|
} |
123 |
|
|
|
|
| - |
Uncovered Elements: 0 (0) |
Complexity: 1 |
Complexity Density: - |
|
124 |
0
|
public void insert(int position, Element element) {... |
125 |
|
} |
126 |
|
|
|
|
| - |
Uncovered Elements: 0 (0) |
Complexity: 1 |
Complexity Density: - |
|
127 |
0
|
public void remove(int i) {... |
128 |
|
} |
129 |
|
|
|
|
| - |
Uncovered Elements: 0 (0) |
Complexity: 1 |
Complexity Density: - |
|
130 |
0
|
public void replace(int position, Element element) {... |
131 |
|
} |
132 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
133 |
0
|
public int size() {... |
134 |
0
|
return 0; |
135 |
|
} |
136 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
137 |
0
|
public Element copy() {... |
138 |
0
|
return null; |
139 |
|
} |
140 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
141 |
0
|
public Atom getAtom() {... |
142 |
0
|
return null; |
143 |
|
} |
144 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
145 |
0
|
public ElementList getList() {... |
146 |
0
|
return null; |
147 |
|
} |
148 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
149 |
1
|
public boolean isAtom() {... |
150 |
1
|
return true; |
151 |
|
} |
152 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
153 |
0
|
public boolean isList() {... |
154 |
0
|
return false; |
155 |
|
} |
156 |
|
|
|
|
| 0% |
Uncovered Elements: 1 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
157 |
0
|
public Element replace(Element search, Element replacement) {... |
158 |
0
|
return null; |
159 |
|
}}); |
160 |
0
|
fail("Exception expected"); |
161 |
|
} catch (Exception e) { |
162 |
|
|
163 |
|
} |
164 |
1
|
assertEquals(one, new ElementSet(new ElementSet(new Element[] {new DefaultAtom("one")}))); |
165 |
1
|
assertEquals(one, new ElementSet( |
166 |
|
new DefaultElementList("list", new Element[] {new DefaultAtom("one")}))); |
167 |
|
} |
168 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (23) |
Complexity: 1 |
Complexity Density: 0.04 |
1
PASS
|
|
169 |
1
|
public void testSetOperations() {... |
170 |
1
|
DefaultAtom o = new DefaultAtom("one"); |
171 |
1
|
DefaultAtom t = new DefaultAtom("two"); |
172 |
1
|
assertTrue(one.contains(o)); |
173 |
1
|
DefaultAtom otto = new DefaultAtom("otto"); |
174 |
1
|
assertFalse(one.contains(otto)); |
175 |
1
|
one.remove(o); |
176 |
1
|
assertEquals(empty, one); |
177 |
1
|
one.remove(otto); |
178 |
1
|
assertEquals(empty, one); |
179 |
1
|
assertTrue(one.isEmpty()); |
180 |
1
|
assertFalse(two.isEmpty()); |
181 |
1
|
two.add(o); |
182 |
1
|
assertEquals(two, oneTwo); |
183 |
1
|
one.add(o); |
184 |
1
|
assertTrue(one.contains(o)); |
185 |
1
|
assertFalse(one.contains(t)); |
186 |
1
|
one.intersection(oneTwo); |
187 |
1
|
assertTrue(one.contains(o)); |
188 |
1
|
assertFalse(one.contains(t)); |
189 |
1
|
one.union(oneTwo); |
190 |
1
|
assertTrue(one.contains(o)); |
191 |
1
|
assertTrue(one.contains(t)); |
192 |
1
|
assertEquals(2, one.size()); |
193 |
|
} |
194 |
|
|
|
|
| 78.6% |
Uncovered Elements: 3 (14) |
Complexity: 4 |
Complexity Density: 0.29 |
1
PASS
|
|
195 |
1
|
public void testSetOperations2() {... |
196 |
1
|
try { |
197 |
1
|
one.isSubset(null); |
198 |
0
|
fail("Exception expected"); |
199 |
|
} catch (Exception e) { |
200 |
|
|
201 |
|
} |
202 |
1
|
assertTrue(one.isSubset(oneTwo)); |
203 |
1
|
assertFalse(oneTwo.isSubset(one)); |
204 |
1
|
assertTrue(oneTwo.isSubset(oneTwo)); |
205 |
1
|
assertTrue(empty.isSubset(oneTwo)); |
206 |
1
|
assertTrue(empty.isSubset(empty)); |
207 |
1
|
try { |
208 |
1
|
one.union(null); |
209 |
0
|
fail("Exception expected"); |
210 |
|
} catch (Exception e) { |
211 |
|
|
212 |
|
} |
213 |
1
|
try { |
214 |
1
|
one.intersection(null); |
215 |
0
|
fail("Exception expected"); |
216 |
|
} catch (Exception e) { |
217 |
|
|
218 |
|
} |
219 |
|
} |
220 |
|
|
|
|
| 94.1% |
Uncovered Elements: 1 (17) |
Complexity: 2 |
Complexity Density: 0.12 |
1
PASS
|
|
221 |
1
|
public void testMinus() {... |
222 |
1
|
try { |
223 |
1
|
one.minus(null); |
224 |
0
|
fail("Exception expected"); |
225 |
|
} catch (Exception e) { |
226 |
|
|
227 |
|
} |
228 |
1
|
assertEquals(oneTwo, oneTwo.minus(empty)); |
229 |
1
|
assertEquals(2, oneTwo.size()); |
230 |
1
|
assertEquals(one, one.minus(one)); |
231 |
1
|
assertEquals(0, one.size()); |
232 |
1
|
initAttributes(); |
233 |
1
|
assertEquals(oneTwo, oneTwo.minus(one)); |
234 |
1
|
assertEquals(new ElementSet(new Element[]{ new DefaultAtom("two")}), oneTwo); |
235 |
1
|
initAttributes(); |
236 |
1
|
assertEquals(oneTwo, oneTwo.minus(two)); |
237 |
1
|
assertEquals(new ElementSet(new Element[]{ new DefaultAtom("one")}), oneTwo); |
238 |
1
|
initAttributes(); |
239 |
1
|
assertEquals(2, oneTwo.size()); |
240 |
1
|
assertEquals(oneTwo, oneTwo.minus(new ElementSet(new Element[] { |
241 |
|
new DefaultAtom("three") }))); |
242 |
1
|
assertEquals(2, oneTwo.size()); |
243 |
|
} |
244 |
|
|
|
|
| 88.9% |
Uncovered Elements: 1 (9) |
Complexity: 2 |
Complexity Density: 0.22 |
1
PASS
|
|
245 |
1
|
public void testRemove() {... |
246 |
1
|
try { |
247 |
1
|
one.remove(null); |
248 |
0
|
fail("Exception expected"); |
249 |
|
} catch (Exception e) { |
250 |
|
|
251 |
|
} |
252 |
1
|
assertEquals(one, one.remove(new DefaultAtom("two"))); |
253 |
1
|
assertEquals(1, one.size()); |
254 |
1
|
assertEquals(two, two.remove(new DefaultAtom("two"))); |
255 |
1
|
assertEquals(empty, two); |
256 |
1
|
assertEquals(0, two.size()); |
257 |
1
|
assertEquals(oneTwo, oneTwo.remove(new DefaultAtom("two"))); |
258 |
|
} |
259 |
|
|
|
|
| 88.9% |
Uncovered Elements: 1 (9) |
Complexity: 2 |
Complexity Density: 0.22 |
1
PASS
|
|
260 |
1
|
public void testAdd() {... |
261 |
1
|
try { |
262 |
1
|
one.add(null); |
263 |
0
|
fail("Exception expected"); |
264 |
|
} catch (Exception e) { |
265 |
|
|
266 |
|
} |
267 |
1
|
assertEquals(one, one.add(new DefaultAtom("two"))); |
268 |
1
|
assertEquals(2, one.size()); |
269 |
1
|
assertEquals(oneTwo, one); |
270 |
1
|
assertEquals(one, one.add(new DefaultAtom("two"))); |
271 |
1
|
assertEquals(2, one.size()); |
272 |
1
|
assertEquals(oneTwo, one); |
273 |
|
} |
274 |
|
|
|
|
| 85.7% |
Uncovered Elements: 1 (7) |
Complexity: 2 |
Complexity Density: 0.29 |
1
PASS
|
|
275 |
1
|
public void testContains() {... |
276 |
1
|
try { |
277 |
1
|
one.contains(null); |
278 |
0
|
fail("Exception expected"); |
279 |
|
} catch (Exception e) { |
280 |
|
|
281 |
|
} |
282 |
1
|
assertFalse(empty.contains(new DefaultAtom("two"))); |
283 |
1
|
assertFalse(one.contains(new DefaultAtom("two"))); |
284 |
1
|
assertTrue(one.contains(new DefaultAtom("one"))); |
285 |
1
|
assertTrue(oneTwo.contains(new DefaultAtom("one"))); |
286 |
|
} |
287 |
|
|
|
|
| 85.7% |
Uncovered Elements: 1 (7) |
Complexity: 2 |
Complexity Density: 0.29 |
1
PASS
|
|
288 |
1
|
public void testNewDelta() {... |
289 |
1
|
try { |
290 |
1
|
one.newDelta(null); |
291 |
0
|
fail("Exception expected"); |
292 |
|
} catch (Exception e) { |
293 |
|
|
294 |
|
} |
295 |
1
|
assertEquals(oneTwo, one.newDelta(two)); |
296 |
1
|
assertEquals(one, oneTwo.newDelta(two)); |
297 |
1
|
assertEquals(two, one.newDelta(oneTwo)); |
298 |
1
|
assertEquals(empty, oneTwo.newDelta(oneTwo)); |
299 |
|
} |
300 |
|
|
|
|
| 88.9% |
Uncovered Elements: 1 (9) |
Complexity: 2 |
Complexity Density: 0.22 |
1
PASS
|
|
301 |
1
|
public void testNewIntersection() {... |
302 |
1
|
try { |
303 |
1
|
one.newIntersection(null); |
304 |
0
|
fail("Exception expected"); |
305 |
|
} catch (Exception e) { |
306 |
|
|
307 |
|
} |
308 |
1
|
assertEquals(empty, one.newIntersection(two)); |
309 |
1
|
assertEquals(0, one.newIntersection(two).size()); |
310 |
1
|
assertEquals(two, oneTwo.newIntersection(two)); |
311 |
1
|
assertEquals(one, one.newIntersection(oneTwo)); |
312 |
1
|
assertEquals(oneTwo, oneTwo.newIntersection(oneTwo)); |
313 |
1
|
assertEquals(2, oneTwo.newIntersection(oneTwo).size()); |
314 |
|
} |
315 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
1
PASS
|
|
316 |
1
|
public void testIsEmpty() {... |
317 |
1
|
assertTrue(empty.isEmpty()); |
318 |
1
|
assertFalse(oneTwo.isEmpty()); |
319 |
|
} |
320 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
1
PASS
|
|
321 |
1
|
public void testIterator() {... |
322 |
1
|
Iterator iterator = empty.iterator(); |
323 |
1
|
assertFalse(iterator.hasNext()); |
324 |
1
|
Iterator iterator2 = one.iterator(); |
325 |
1
|
assertTrue(iterator2.hasNext()); |
326 |
1
|
assertEquals(new DefaultAtom("one"), iterator2.next()); |
327 |
1
|
assertFalse(iterator2.hasNext()); |
328 |
|
} |
329 |
|
|
330 |
|
|
331 |
|
|
332 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0.17 |
1
PASS
|
|
333 |
1
|
public void testToString() {... |
334 |
1
|
assertEquals("{}", empty.toString()); |
335 |
1
|
assertEquals("{\"one\"}", one.toString()); |
336 |
1
|
assertEquals("{\"two\"}", two.toString()); |
337 |
1
|
assertEquals("{\"two\"}", two2.toString()); |
338 |
1
|
assertEquals("{\"ho\"\"hi\"}", new ElementSet(new Element[] {new DefaultAtom("ho\"hi")}) |
339 |
|
.toString()); |
340 |
1
|
assertTrue("{\"one\", \"two\"}".equals(oneTwo.toString()) |
341 |
|
|| "{\"two\", \"one\"}".equals(oneTwo.toString())); |
342 |
|
} |
343 |
|
|
344 |
|
|
345 |
|
|
346 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (4) |
Complexity: 1 |
Complexity Density: 0.25 |
1
PASS
|
|
347 |
1
|
public void testHashCode() {... |
348 |
1
|
assertFalse(empty.hashCode() == two2.hashCode()); |
349 |
1
|
assertFalse(empty.hashCode() == one.hashCode()); |
350 |
1
|
assertFalse(two.hashCode() == one.hashCode()); |
351 |
1
|
assertTrue(two.hashCode() == two2.hashCode()); |
352 |
|
} |
353 |
|
|
354 |
|
|
355 |
|
|
356 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (17) |
Complexity: 1 |
Complexity Density: 0.06 |
1
PASS
|
|
357 |
1
|
public void testEquals() {... |
358 |
1
|
assertFalse(empty.equals(null)); |
359 |
1
|
assertFalse(empty.equals(one)); |
360 |
1
|
assertFalse(empty.equals(two)); |
361 |
1
|
assertFalse(empty.equals(two2)); |
362 |
1
|
assertFalse(one.equals(null)); |
363 |
1
|
assertTrue(one.equals(one)); |
364 |
1
|
assertFalse(one.equals(two)); |
365 |
1
|
assertFalse(one.equals(two2)); |
366 |
1
|
assertFalse(two.equals(null)); |
367 |
1
|
assertFalse(two.equals(one)); |
368 |
1
|
assertTrue(two.equals(two)); |
369 |
1
|
assertTrue(two.equals(two2)); |
370 |
1
|
assertFalse(two2.equals(null)); |
371 |
1
|
assertFalse(two2.equals(one)); |
372 |
1
|
assertTrue(two2.equals(two)); |
373 |
1
|
assertTrue(two2.equals(two2)); |
374 |
1
|
assertFalse(empty.equals(new ElementSet() {})); |
375 |
|
} |
376 |
|
|
377 |
|
} |