1 |
|
package org.sat4j.core; |
2 |
|
|
3 |
|
import java.util.Comparator; |
4 |
|
import java.util.Iterator; |
5 |
|
import java.util.NoSuchElementException; |
6 |
|
|
7 |
|
import junit.framework.TestCase; |
8 |
|
|
9 |
|
import org.sat4j.specs.IVec; |
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
@author |
18 |
|
|
19 |
|
|
|
|
| 99,5% |
Uncovered Elements: 1 (218) |
Complexity: 16 |
Complexity Density: 0,26 |
|
20 |
|
public class VecTest extends TestCase { |
21 |
|
|
22 |
|
|
23 |
|
|
24 |
|
|
25 |
|
@param |
26 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
27 |
24
|
public VecTest(String arg0) {... |
28 |
24
|
super(arg0); |
29 |
|
} |
30 |
|
|
31 |
|
|
32 |
|
@see |
33 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0,5 |
|
34 |
24
|
@Override... |
35 |
|
protected void setUp() throws Exception { |
36 |
24
|
super.setUp(); |
37 |
24
|
myvec = new Vec<Integer>(); |
38 |
|
} |
39 |
|
|
40 |
|
|
41 |
|
@see |
42 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (1) |
Complexity: 1 |
Complexity Density: 1 |
|
43 |
24
|
@Override... |
44 |
|
protected void tearDown() throws Exception { |
45 |
24
|
super.tearDown(); |
46 |
|
} |
47 |
|
|
48 |
|
|
49 |
|
|
50 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0,5 |
1
PASS
|
|
51 |
1
|
public void testVec() {... |
52 |
1
|
IVec<Integer> vec = new Vec<Integer>(); |
53 |
1
|
assertEquals(0, vec.size()); |
54 |
|
} |
55 |
|
|
56 |
|
|
57 |
|
|
58 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0,33 |
1
PASS
|
|
59 |
1
|
public void testVecint() {... |
60 |
1
|
IVec<Integer> vec = new Vec<Integer>(10, new Integer(0)); |
61 |
1
|
assertEquals(new Integer(0), vec.last()); |
62 |
1
|
assertEquals(10, vec.size()); |
63 |
|
} |
64 |
|
|
65 |
|
|
66 |
|
|
67 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (4) |
Complexity: 1 |
Complexity Density: 0,25 |
1
PASS
|
|
68 |
1
|
public void testVecintObject() {... |
69 |
1
|
Integer pad = new Integer(10); |
70 |
1
|
IVec<Integer> vec = new Vec<Integer>(10, pad); |
71 |
1
|
assertEquals(pad, vec.last()); |
72 |
1
|
assertEquals(10, vec.size()); |
73 |
|
|
74 |
|
} |
75 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (9) |
Complexity: 1 |
Complexity Density: 0,11 |
1
PASS
|
|
76 |
1
|
public void testSize() {... |
77 |
1
|
assertEquals(0, myvec.size()); |
78 |
1
|
myvec.push(null); |
79 |
1
|
assertEquals(1, myvec.size()); |
80 |
1
|
myvec.push(null); |
81 |
1
|
assertEquals(2, myvec.size()); |
82 |
1
|
myvec.pop(); |
83 |
1
|
assertEquals(1, myvec.size()); |
84 |
1
|
myvec.pop(); |
85 |
1
|
assertEquals(0, myvec.size()); |
86 |
|
} |
87 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 2 |
Complexity Density: 0,22 |
1
PASS
|
|
88 |
1
|
public void testShrink() {... |
89 |
16
|
for (int i = 0; i < 15; i++) { |
90 |
15
|
myvec.push(new Integer(i)); |
91 |
|
} |
92 |
1
|
assertEquals(15, myvec.size()); |
93 |
1
|
myvec.shrink(10); |
94 |
1
|
assertEquals(5, myvec.size()); |
95 |
1
|
assertEquals(new Integer(4), myvec.last()); |
96 |
1
|
myvec.shrink(0); |
97 |
1
|
assertEquals(5, myvec.size()); |
98 |
1
|
assertEquals(new Integer(4), myvec.last()); |
99 |
|
} |
100 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 2 |
Complexity Density: 0,22 |
1
PASS
|
|
101 |
1
|
public void testShrinkTo() {... |
102 |
16
|
for (int i = 0; i < 15; i++) { |
103 |
15
|
myvec.push(new Integer(i)); |
104 |
|
} |
105 |
1
|
assertEquals(15, myvec.size()); |
106 |
1
|
myvec.shrinkTo(10); |
107 |
1
|
assertEquals(10, myvec.size()); |
108 |
1
|
assertEquals(new Integer(9), myvec.last()); |
109 |
1
|
myvec.shrinkTo(10); |
110 |
1
|
assertEquals(10, myvec.size()); |
111 |
1
|
assertEquals(new Integer(9), myvec.last()); |
112 |
|
|
113 |
|
} |
114 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 2 |
Complexity Density: 0,33 |
1
PASS
|
|
115 |
1
|
public void testPop() {... |
116 |
16
|
for (int i = 0; i < 15; i++) { |
117 |
15
|
myvec.push(new Integer(i)); |
118 |
|
} |
119 |
1
|
assertEquals(15, myvec.size()); |
120 |
1
|
myvec.pop(); |
121 |
1
|
assertEquals(14, myvec.size()); |
122 |
1
|
assertEquals(new Integer(13), myvec.last()); |
123 |
|
} |
124 |
|
|
125 |
|
|
126 |
|
|
127 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0,14 |
1
PASS
|
|
128 |
1
|
public void testGrowToint() {... |
129 |
1
|
assertEquals(0, myvec.size()); |
130 |
1
|
myvec.growTo(12, null); |
131 |
1
|
assertEquals(12, myvec.size()); |
132 |
1
|
assertNull(myvec.last()); |
133 |
1
|
myvec.growTo(20, null); |
134 |
1
|
assertEquals(20, myvec.size()); |
135 |
1
|
assertNull(myvec.last()); |
136 |
|
} |
137 |
|
|
138 |
|
|
139 |
|
|
140 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (9) |
Complexity: 1 |
Complexity Density: 0,11 |
1
PASS
|
|
141 |
1
|
public void testGrowTointObject() {... |
142 |
1
|
assertEquals(0, myvec.size()); |
143 |
1
|
Integer douze = new Integer(12); |
144 |
1
|
myvec.growTo(12, douze); |
145 |
1
|
assertEquals(12, myvec.size()); |
146 |
1
|
assertEquals(douze, myvec.last()); |
147 |
1
|
Integer treize = new Integer(13); |
148 |
1
|
myvec.growTo(20, treize); |
149 |
1
|
assertEquals(20, myvec.size()); |
150 |
1
|
assertEquals(treize, myvec.last()); |
151 |
|
} |
152 |
|
|
153 |
|
|
154 |
|
|
155 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 2 |
Complexity Density: 0,4 |
1
PASS
|
|
156 |
1
|
public void testPush() {... |
157 |
1
|
assertEquals(0, myvec.size()); |
158 |
11
|
for (int i = 0; i < 10; i++) { |
159 |
10
|
myvec.push(new Integer(0)); |
160 |
|
} |
161 |
1
|
assertEquals(10, myvec.size()); |
162 |
1
|
assertEquals(new Integer(0), myvec.last()); |
163 |
|
} |
164 |
|
|
165 |
|
|
166 |
|
|
167 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 2 |
Complexity Density: 0,33 |
1
PASS
|
|
168 |
1
|
public void testPushObject() {... |
169 |
1
|
Integer deux = new Integer(2); |
170 |
1
|
assertEquals(0, myvec.size()); |
171 |
11
|
for (int i = 0; i < 10; i++) { |
172 |
10
|
myvec.push(deux); |
173 |
|
} |
174 |
1
|
assertEquals(10, myvec.size()); |
175 |
1
|
assertEquals(deux, myvec.last()); |
176 |
|
} |
177 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (4) |
Complexity: 1 |
Complexity Density: 0,25 |
1
PASS
|
|
178 |
1
|
public void testClear() {... |
179 |
1
|
myvec.push(null); |
180 |
1
|
myvec.push(null); |
181 |
1
|
myvec.clear(); |
182 |
1
|
assertEquals(0, myvec.size()); |
183 |
|
} |
184 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 2 |
Complexity Density: 0,5 |
1
PASS
|
|
185 |
1
|
public void testLast() {... |
186 |
11
|
for (int i = 0; i < 10; i++) { |
187 |
10
|
Integer myint = new Integer(i); |
188 |
10
|
myvec.push(myint); |
189 |
10
|
assertEquals(myint, myvec.last()); |
190 |
|
} |
191 |
|
} |
192 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 2 |
Complexity Density: 0,5 |
1
PASS
|
|
193 |
1
|
public void testGet() {... |
194 |
11
|
for (int i = 0; i < 10; i++) { |
195 |
10
|
Integer myint = new Integer(i); |
196 |
10
|
myvec.push(myint); |
197 |
10
|
assertEquals(myint, myvec.get(i)); |
198 |
|
} |
199 |
|
} |
200 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0,17 |
1
PASS
|
|
201 |
1
|
public void testCopyTo() {... |
202 |
1
|
Vec<Integer> nvec = new Vec<Integer>(); |
203 |
1
|
myvec.growTo(15, new Integer(15)); |
204 |
1
|
myvec.copyTo(nvec); |
205 |
1
|
assertEquals(15, nvec.size()); |
206 |
1
|
assertEquals(15, myvec.size()); |
207 |
1
|
assertEquals(myvec.last(), nvec.last()); |
208 |
|
|
209 |
|
} |
210 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (6) |
Complexity: 1 |
Complexity Density: 0,17 |
1
PASS
|
|
211 |
1
|
public void testMoveTo() {... |
212 |
1
|
Vec<Integer> nvec = new Vec<Integer>(); |
213 |
1
|
myvec.growTo(15, new Integer(15)); |
214 |
1
|
myvec.moveTo(nvec); |
215 |
1
|
assertEquals(15, nvec.size()); |
216 |
1
|
assertEquals(0, myvec.size()); |
217 |
1
|
assertEquals(new Integer(15), nvec.last()); |
218 |
|
} |
219 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 3 |
Complexity Density: 0,43 |
1
PASS
|
|
220 |
1
|
public void testSelectionSort() {... |
221 |
1
|
Vec<Integer> nvec = new Vec<Integer>(); |
222 |
31
|
for (int i = 30; i > 0; i--) { |
223 |
30
|
nvec.push(new Integer(i)); |
224 |
|
} |
225 |
1
|
Comparator<Integer> comp = new DefaultComparator<Integer>(); |
226 |
1
|
nvec.selectionSort(0, 30, comp); |
227 |
31
|
for (int i = 1; i <= 30; i++) { |
228 |
30
|
assertEquals(i, nvec.get(i - 1).intValue()); |
229 |
|
} |
230 |
|
} |
231 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (13) |
Complexity: 3 |
Complexity Density: 0,33 |
1
PASS
|
|
232 |
1
|
public void testSort() {... |
233 |
1
|
IVec<Integer> nvec = new Vec<Integer>(); |
234 |
102
|
for (int i = 101; i > 0; i--) { |
235 |
101
|
nvec.push(new Integer(i)); |
236 |
|
} |
237 |
1
|
nvec.push(new Integer(30)); |
238 |
1
|
nvec.push(new Integer(40)); |
239 |
1
|
Comparator<Integer> comp = new DefaultComparator<Integer>(); |
240 |
1
|
nvec.sort(comp); |
241 |
31
|
for (int i = 1; i <= 30; i++) { |
242 |
30
|
assertEquals(i, nvec.get(i - 1).intValue()); |
243 |
|
} |
244 |
|
} |
245 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0,33 |
1
PASS
|
|
246 |
1
|
public void testSortEmpty() {... |
247 |
1
|
IVec<Integer> nvec = new Vec<Integer>(); |
248 |
1
|
Comparator<Integer> comp = new DefaultComparator<Integer>(); |
249 |
1
|
nvec.sort(comp); |
250 |
|
} |
251 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (16) |
Complexity: 3 |
Complexity Density: 0,25 |
1
PASS
|
|
252 |
1
|
public void testSortUnique() {... |
253 |
1
|
IVec<Integer> nvec = new Vec<Integer>(); |
254 |
102
|
for (int i = 101; i > 0; i--) { |
255 |
101
|
nvec.push(new Integer(i)); |
256 |
|
} |
257 |
1
|
nvec.push(new Integer(30)); |
258 |
1
|
nvec.push(new Integer(40)); |
259 |
1
|
nvec.push(new Integer(50)); |
260 |
1
|
nvec.push(new Integer(55)); |
261 |
1
|
nvec.push(new Integer(60)); |
262 |
1
|
Comparator<Integer> comp = new DefaultComparator<Integer>(); |
263 |
1
|
nvec.sortUnique(comp); |
264 |
102
|
for (int i = 1; i <= 101; i++) { |
265 |
101
|
assertEquals(i, nvec.get(i - 1).intValue()); |
266 |
|
} |
267 |
|
} |
268 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (10) |
Complexity: 2 |
Complexity Density: 0,25 |
1
PASS
|
|
269 |
1
|
public void testDelete() {... |
270 |
1
|
IVec<Integer> nvec = new Vec<Integer>(); |
271 |
101
|
for (int i = 0; i < 100; i++) { |
272 |
100
|
nvec.push(new Integer(i)); |
273 |
|
} |
274 |
1
|
assertEquals(new Integer(10), nvec.delete(10)); |
275 |
1
|
assertEquals(new Integer(99), nvec.get(10)); |
276 |
1
|
nvec.clear(); |
277 |
1
|
nvec.push(new Integer(1)); |
278 |
1
|
assertEquals(new Integer(1), nvec.delete(0)); |
279 |
|
} |
280 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (9) |
Complexity: 1 |
Complexity Density: 0,11 |
1
PASS
|
|
281 |
1
|
public void testEquals() {... |
282 |
1
|
IVec<Integer> nvec = new Vec<Integer>(3, new Integer(2)); |
283 |
1
|
IVec<Integer> vect = new Vec<Integer>(3, new Integer(2)); |
284 |
1
|
IVec<Integer> vecf = new Vec<Integer>(4, new Integer(2)); |
285 |
1
|
IVec<Integer> vecf2 = new Vec<Integer>(2, new Integer(2)); |
286 |
1
|
IVec<Integer> vecf3 = new Vec<Integer>(3, new Integer(3)); |
287 |
1
|
assertEquals(nvec, vect); |
288 |
1
|
assertFalse(nvec.equals(vecf)); |
289 |
1
|
assertFalse(nvec.equals(vecf2)); |
290 |
1
|
assertFalse(nvec.equals(vecf3)); |
291 |
|
|
292 |
|
} |
293 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (12) |
Complexity: 1 |
Complexity Density: 0,08 |
1
PASS
|
|
294 |
1
|
public void testIterator() {... |
295 |
1
|
Vec<String> str = new Vec<String>(); |
296 |
1
|
str.push("titi"); |
297 |
1
|
str.push("toto"); |
298 |
1
|
str.push("tata"); |
299 |
1
|
Iterator<String> it = str.iterator(); |
300 |
1
|
assertTrue(it.hasNext()); |
301 |
1
|
assertEquals("titi", it.next()); |
302 |
1
|
assertTrue(it.hasNext()); |
303 |
1
|
assertEquals("toto", it.next()); |
304 |
1
|
assertTrue(it.hasNext()); |
305 |
1
|
assertEquals("tata", it.next()); |
306 |
1
|
assertFalse(it.hasNext()); |
307 |
|
} |
308 |
|
|
|
|
| 83,3% |
Uncovered Elements: 1 (6) |
Complexity: 2 |
Complexity Density: 0,33 |
1
PASS
|
|
309 |
1
|
public void testNoSuchElementException() {... |
310 |
1
|
Vec<String> str = new Vec<String>(); |
311 |
1
|
Iterator<String> it = str.iterator(); |
312 |
1
|
assertFalse(it.hasNext()); |
313 |
1
|
try { |
314 |
1
|
it.next(); |
315 |
0
|
fail(); |
316 |
|
} catch (NoSuchElementException e) { |
317 |
|
|
318 |
|
} |
319 |
|
} |
320 |
|
|
321 |
|
private IVec<Integer> myvec; |
322 |
|
|
323 |
|
} |