Clover Coverage Report
Coverage timestamp: Fri May 24 2013 13:47:27 UTC
Overview   Package   File
    FRAMES   NO FRAMES     
172   377   46   5.21
0   282   0.27   33
33     1.39  
1    
 
  ElementSetTest       Line # 31 172 46 82% 0.8195122
 
  (14)
 
1    /* This file is part of the project "Hilbert II" - http://www.qedeq.org
2    *
3    * Copyright 2000-2013, Michael Meyling <mime@qedeq.org>.
4    *
5    * "Hilbert II" is free software; you can redistribute
6    * it and/or modify it under the terms of the GNU General Public
7    * License as published by the Free Software Foundation; either
8    * version 2 of the License, or (at your option) any later version.
9    *
10    * This program is distributed in the hope that it will be useful,
11    * but WITHOUT ANY WARRANTY; without even the implied warranty of
12    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13    * GNU General Public License for more details.
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    * Test class.
28    *
29    * @author Michael Meyling
30    */
 
31    public class ElementSetTest extends QedeqTestCase {
32   
33    /** {} */
34    private ElementSet empty;
35   
36    /** {"one"} */
37    private ElementSet one;
38   
39    /** {"two"} */
40    private ElementSet two;
41   
42    /** {"two"} */
43    private ElementSet two2;
44   
45    /** {"one", "two"} */
46    private ElementSet oneTwo;
47   
 
48  0 toggle public ElementSetTest(){
49  0 super();
50    }
51   
 
52  14 toggle public ElementSetTest(final String name){
53  14 super(name);
54    }
55   
 
56  14 toggle protected void setUp() throws Exception {
57  14 super.setUp();
58  14 initAttributes();
59    }
60   
61    /**
62    *
63    */
 
64  17 toggle 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   
 
75  14 toggle 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    * Test constructor.
87    */
 
88  1 toggle public void testConstructor() {
89  1 try {
90  1 new ElementSet((Element []) null);
91  0 fail("Exception expected");
92    } catch (Exception e) {
93    // ok
94    }
95  1 try {
96  1 new ElementSet((ElementSet) null);
97  0 fail("Exception expected");
98    } catch (Exception e) {
99    // ok
100    }
101  1 try {
102  1 new ElementSet((ElementList) null);
103  0 fail("Exception expected");
104    } catch (Exception e) {
105    // ok
106    }
107  1 try {
108  1 new ElementSet(new ElementList() {
 
109  0 toggle public void add(Element element) {
110    }
111   
 
112  0 toggle public Element getElement(int i) {
113  0 return null;
114    }
115   
 
116  0 toggle public List getElements() {
117  0 return null;
118    }
119   
 
120  0 toggle public String getOperator() {
121  0 return null;
122    }
123   
 
124  0 toggle public void insert(int position, Element element) {
125    }
126   
 
127  0 toggle public void remove(int i) {
128    }
129   
 
130  0 toggle public void replace(int position, Element element) {
131    }
132   
 
133  0 toggle public int size() {
134  0 return 0;
135    }
136   
 
137  0 toggle public Element copy() {
138  0 return null;
139    }
140   
 
141  0 toggle public Atom getAtom() {
142  0 return null;
143    }
144   
 
145  0 toggle public ElementList getList() {
146  0 return null;
147    }
148   
 
149  1 toggle public boolean isAtom() {
150  1 return true;
151    }
152   
 
153  0 toggle public boolean isList() {
154  0 return false;
155    }
156   
 
157  0 toggle public Element replace(Element search, Element replacement) {
158  0 return null;
159    }});
160  0 fail("Exception expected");
161    } catch (Exception e) {
162    // ok
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   
 
169  1 toggle 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   
 
195  1 toggle public void testSetOperations2() {
196  1 try {
197  1 one.isSubset(null);
198  0 fail("Exception expected");
199    } catch (Exception e) {
200    // ok
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    // ok
212    }
213  1 try {
214  1 one.intersection(null);
215  0 fail("Exception expected");
216    } catch (Exception e) {
217    // ok
218    }
219    }
220   
 
221  1 toggle public void testMinus() {
222  1 try {
223  1 one.minus(null);
224  0 fail("Exception expected");
225    } catch (Exception e) {
226    // ok
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   
 
245  1 toggle public void testRemove() {
246  1 try {
247  1 one.remove(null);
248  0 fail("Exception expected");
249    } catch (Exception e) {
250    // ok
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   
 
260  1 toggle public void testAdd() {
261  1 try {
262  1 one.add(null);
263  0 fail("Exception expected");
264    } catch (Exception e) {
265    // ok
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   
 
275  1 toggle public void testContains() {
276  1 try {
277  1 one.contains(null);
278  0 fail("Exception expected");
279    } catch (Exception e) {
280    // ok
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   
 
288  1 toggle public void testNewDelta() {
289  1 try {
290  1 one.newDelta(null);
291  0 fail("Exception expected");
292    } catch (Exception e) {
293    // ok
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   
 
301  1 toggle public void testNewIntersection() {
302  1 try {
303  1 one.newIntersection(null);
304  0 fail("Exception expected");
305    } catch (Exception e) {
306    // ok
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   
 
316  1 toggle public void testIsEmpty() {
317  1 assertTrue(empty.isEmpty());
318  1 assertFalse(oneTwo.isEmpty());
319    }
320   
 
321  1 toggle 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    * Test toString.
332    */
 
333  1 toggle 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    * Test hashCode.
346    */
 
347  1 toggle 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    * Test equals.
356    */
 
357  1 toggle 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    }
 
CloverReport generated by Clover Code Coverage v3.1.10
Fri May 24 2013 13:47:32 UTC.		   Clover: Open Source License registered to qedeq.org .