1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
package org.qedeq.base.io; |
17 |
|
|
18 |
|
import java.util.Iterator; |
19 |
|
|
20 |
|
import org.qedeq.base.io.Version; |
21 |
|
import org.qedeq.base.io.VersionSet; |
22 |
|
import org.qedeq.base.test.QedeqTestCase; |
23 |
|
|
24 |
|
|
25 |
|
@link |
26 |
|
|
27 |
|
@author |
28 |
|
|
|
|
| 92.3% |
Uncovered Elements: 12 (156) |
Complexity: 19 |
Complexity Density: 0.13 |
|
29 |
|
public class VersionSetTest extends QedeqTestCase { |
30 |
|
|
31 |
|
private Version version1; |
32 |
|
|
33 |
|
private Version version2; |
34 |
|
|
35 |
|
private Version version3; |
36 |
|
|
37 |
|
private Version version4; |
38 |
|
|
39 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (5) |
Complexity: 1 |
Complexity Density: 0.2 |
|
40 |
6
|
protected void setUp() throws Exception {... |
41 |
6
|
super.setUp(); |
42 |
6
|
version1 = new Version("0.00.00"); |
43 |
6
|
version2 = new Version("0.01.00"); |
44 |
6
|
version3 = new Version("0.02.01"); |
45 |
6
|
version4 = new Version("1.00.00"); |
46 |
|
} |
47 |
|
|
48 |
|
|
49 |
|
|
50 |
|
|
51 |
|
@throws |
52 |
|
|
|
|
| 70.7% |
Uncovered Elements: 12 (41) |
Complexity: 13 |
Complexity Density: 0.32 |
1
PASS
|
|
53 |
1
|
public void testConstructors() throws Exception {... |
54 |
1
|
final VersionSet v1 = new VersionSet(version1.toString()); |
55 |
1
|
assertTrue(v1.contains(version1)); |
56 |
1
|
final VersionSet v2 = new VersionSet(); |
57 |
1
|
assertTrue(v2.isEmpty()); |
58 |
1
|
try { |
59 |
1
|
new VersionSet(""); |
60 |
0
|
fail("exception expected"); |
61 |
|
} catch (IllegalArgumentException e) { |
62 |
|
|
63 |
|
} |
64 |
1
|
try { |
65 |
1
|
new VersionSet(null); |
66 |
0
|
fail("exception expected"); |
67 |
|
} catch (NullPointerException e) { |
68 |
|
|
69 |
|
} |
70 |
1
|
try { |
71 |
1
|
new VersionSet("1"); |
72 |
0
|
fail("exception expected"); |
73 |
|
} catch (IllegalArgumentException e) { |
74 |
|
|
75 |
|
} |
76 |
1
|
try { |
77 |
1
|
new VersionSet("1."); |
78 |
0
|
fail("exception expected"); |
79 |
|
} catch (IllegalArgumentException e) { |
80 |
|
|
81 |
|
} |
82 |
1
|
try { |
83 |
1
|
new VersionSet("1.2"); |
84 |
0
|
fail("exception expected"); |
85 |
|
} catch (IllegalArgumentException e) { |
86 |
|
|
87 |
|
} |
88 |
1
|
try { |
89 |
1
|
new VersionSet("1.2."); |
90 |
0
|
fail("exception expected"); |
91 |
|
} catch (IllegalArgumentException e) { |
92 |
|
|
93 |
|
} |
94 |
1
|
try { |
95 |
1
|
new VersionSet("1.2.3."); |
96 |
0
|
fail("exception expected"); |
97 |
|
} catch (IllegalArgumentException e) { |
98 |
|
|
99 |
|
} |
100 |
1
|
try { |
101 |
1
|
new VersionSet("1.2.3.4"); |
102 |
0
|
fail("exception expected"); |
103 |
|
} catch (IllegalArgumentException e) { |
104 |
|
|
105 |
|
} |
106 |
1
|
try { |
107 |
1
|
new VersionSet("+1.2.3"); |
108 |
0
|
fail("exception expected"); |
109 |
|
} catch (IllegalArgumentException e) { |
110 |
|
|
111 |
|
} |
112 |
1
|
try { |
113 |
1
|
new VersionSet("-1.2.3"); |
114 |
0
|
fail("exception expected"); |
115 |
|
} catch (IllegalArgumentException e) { |
116 |
|
|
117 |
|
} |
118 |
1
|
try { |
119 |
1
|
new VersionSet("null"); |
120 |
0
|
fail("exception expected"); |
121 |
|
} catch (IllegalArgumentException e) { |
122 |
|
|
123 |
|
} |
124 |
1
|
new VersionSet("1234567890.1234567890.1234567890"); |
125 |
1
|
try { |
126 |
1
|
new VersionSet("12345678901.12345678901.12345678901"); |
127 |
0
|
fail("exception expected"); |
128 |
|
} catch (IllegalArgumentException e) { |
129 |
|
|
130 |
|
} |
131 |
|
} |
132 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (34) |
Complexity: 1 |
Complexity Density: 0.03 |
1
PASS
|
|
133 |
1
|
public void testAddAndContainsClearIsEmpty() throws Exception {... |
134 |
1
|
final VersionSet v1 = new VersionSet(); |
135 |
1
|
assertFalse(v1.contains(version1)); |
136 |
1
|
assertFalse(v1.contains(version1.toString())); |
137 |
1
|
assertTrue(v1.isEmpty()); |
138 |
1
|
assertFalse(v1.contains(version2)); |
139 |
1
|
assertFalse(v1.contains(version3)); |
140 |
1
|
assertFalse(v1.contains(version4)); |
141 |
1
|
assertFalse(v1.contains(version2.toString())); |
142 |
1
|
assertFalse(v1.contains(version3.toString())); |
143 |
1
|
assertFalse(v1.contains(version4.toString())); |
144 |
1
|
v1.add(version1); |
145 |
1
|
assertFalse(v1.isEmpty()); |
146 |
1
|
v1.add(version2.toString()); |
147 |
1
|
v1.add(version3); |
148 |
1
|
v1.add(version4.toString()); |
149 |
1
|
assertTrue(v1.contains(version1)); |
150 |
1
|
assertTrue(v1.contains(version2)); |
151 |
1
|
assertTrue(v1.contains(version3)); |
152 |
1
|
assertTrue(v1.contains(version4)); |
153 |
1
|
assertTrue(v1.contains(version1.toString())); |
154 |
1
|
assertTrue(v1.contains(version2.toString())); |
155 |
1
|
assertTrue(v1.contains(version3.toString())); |
156 |
1
|
assertTrue(v1.contains(version4.toString())); |
157 |
1
|
v1.clear(); |
158 |
1
|
assertFalse(v1.contains(version1)); |
159 |
1
|
assertFalse(v1.contains(version1.toString())); |
160 |
1
|
assertTrue(v1.isEmpty()); |
161 |
1
|
assertFalse(v1.contains(version2)); |
162 |
1
|
assertFalse(v1.contains(version3)); |
163 |
1
|
assertFalse(v1.contains(version4)); |
164 |
1
|
assertFalse(v1.contains(version2.toString())); |
165 |
1
|
assertFalse(v1.contains(version3.toString())); |
166 |
1
|
assertFalse(v1.contains(version4.toString())); |
167 |
1
|
assertFalse(v1.contains("1.2.3.4")); |
168 |
|
} |
169 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (33) |
Complexity: 1 |
Complexity Density: 0.03 |
1
PASS
|
|
170 |
1
|
public void testAddAndEquals() throws Exception {... |
171 |
1
|
final VersionSet v1 = new VersionSet(); |
172 |
1
|
v1.add(version1); |
173 |
1
|
v1.add(version2.toString()); |
174 |
1
|
final VersionSet v2 = new VersionSet(); |
175 |
1
|
v2.add(version3); |
176 |
1
|
v2.add(version4.toString()); |
177 |
1
|
final VersionSet v3 = new VersionSet(); |
178 |
1
|
v3.add(version2.toString()); |
179 |
1
|
v3.add(version4.toString()); |
180 |
1
|
v3.add(version1); |
181 |
1
|
v3.add(version3); |
182 |
1
|
final VersionSet v4 = new VersionSet(); |
183 |
1
|
v4.add(version1); |
184 |
1
|
v4.add(version2); |
185 |
1
|
assertTrue(v1.equals(v1)); |
186 |
1
|
assertTrue(v2.equals(v2)); |
187 |
1
|
assertTrue(v3.equals(v3)); |
188 |
1
|
assertTrue(v4.equals(v4)); |
189 |
1
|
assertFalse(v1.equals(v2)); |
190 |
1
|
assertFalse(v1.equals(v3)); |
191 |
1
|
assertTrue(v1.equals(v4)); |
192 |
1
|
assertFalse(v2.equals(v1)); |
193 |
1
|
assertFalse(v3.equals(v1)); |
194 |
1
|
assertTrue(v4.equals(v1)); |
195 |
1
|
assertFalse(v2.equals(v3)); |
196 |
1
|
assertFalse(v3.equals(v2)); |
197 |
1
|
assertFalse(v2.equals(v4)); |
198 |
1
|
assertFalse(v4.equals(v2)); |
199 |
1
|
v1.addAll(v2); |
200 |
1
|
assertEquals(v1, v3); |
201 |
1
|
assertFalse(v1.equals(null)); |
202 |
1
|
assertFalse(v2.equals("")); |
203 |
1
|
assertFalse(v4.equals("other")); |
204 |
|
} |
205 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (12) |
Complexity: 1 |
Complexity Density: 0.08 |
1
PASS
|
|
206 |
1
|
public void testIterator() throws Exception {... |
207 |
1
|
final VersionSet v1 = new VersionSet(); |
208 |
1
|
v1.add("0.02.00"); |
209 |
1
|
v1.add("0.01.00"); |
210 |
1
|
v1.add("0.00.30"); |
211 |
1
|
Iterator i = v1.iterator(); |
212 |
1
|
assertTrue(i.hasNext()); |
213 |
1
|
assertEquals(new Version("0.00.30"), i.next()); |
214 |
1
|
assertTrue(i.hasNext()); |
215 |
1
|
assertEquals(new Version("0.01.00"), i.next()); |
216 |
1
|
assertTrue(i.hasNext()); |
217 |
1
|
assertEquals(new Version("0.02.00"), i.next()); |
218 |
1
|
assertFalse(i.hasNext()); |
219 |
|
} |
220 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 1 |
Complexity Density: 0.09 |
1
PASS
|
|
221 |
1
|
public void testHashCode() {... |
222 |
1
|
final VersionSet v1 = new VersionSet(); |
223 |
1
|
v1.add(version1); |
224 |
1
|
v1.add(version2.toString()); |
225 |
1
|
final VersionSet v2 = new VersionSet(); |
226 |
1
|
v2.add(version3); |
227 |
1
|
v2.add(version4.toString()); |
228 |
1
|
assertFalse(v1.hashCode() == v2.hashCode()); |
229 |
1
|
final VersionSet v3 = new VersionSet(); |
230 |
1
|
v3.add(version1); |
231 |
1
|
v3.add(version2); |
232 |
1
|
assertTrue(v1.hashCode() == v3.hashCode()); |
233 |
|
} |
234 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (13) |
Complexity: 1 |
Complexity Density: 0.08 |
1
PASS
|
|
235 |
1
|
public void testToString() {... |
236 |
1
|
final VersionSet v1 = new VersionSet(); |
237 |
1
|
assertEquals("{}", v1.toString()); |
238 |
1
|
v1.add("0.00.01"); |
239 |
1
|
v1.add("0.00.02"); |
240 |
1
|
assertEquals("{0.00.01, 0.00.02}", v1.toString()); |
241 |
1
|
final VersionSet v2 = new VersionSet(); |
242 |
1
|
v2.add("0.00.01"); |
243 |
1
|
assertEquals("{0.00.01}", v2.toString()); |
244 |
1
|
v2.add("0.00.01"); |
245 |
1
|
assertEquals("{0.00.01}", v2.toString()); |
246 |
1
|
final VersionSet v3 = new VersionSet(); |
247 |
1
|
v3.add("0.0.0"); |
248 |
1
|
assertEquals("{0.00.00}", v3.toString()); |
249 |
|
} |
250 |
|
} |