1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30 package org.sat4j.tools;
31
32 import static org.junit.Assert.assertEquals;
33
34 import java.util.List;
35
36 import org.junit.Before;
37 import org.junit.Test;
38 import org.sat4j.core.VecInt;
39 import org.sat4j.minisat.SolverFactory;
40 import org.sat4j.specs.ContradictionException;
41 import org.sat4j.specs.IConstr;
42 import org.sat4j.specs.ISolver;
43 import org.sat4j.specs.IVecInt;
44 import org.sat4j.specs.TimeoutException;
45
46 public class TestAllMUSesAndCheckTest {
47
48 private AllMUSes allMUSes;
49 private ISolver solver;
50 private CheckMUSSolutionListener checkListener;
51
52 @Before
53 public void setUp() throws Exception {
54 this.allMUSes = new AllMUSes(SolverFactory.instance());
55 this.solver = allMUSes.getSolverInstance();
56 this.checkListener = new CheckMUSSolutionListener(
57 SolverFactory.instance());
58 }
59
60 @Test
61 public void testSimpleCase() {
62 IVecInt c1 = new VecInt();
63 IVecInt c2 = new VecInt();
64 IVecInt c3 = new VecInt();
65 IVecInt c4 = new VecInt();
66 IVecInt c5 = new VecInt();
67
68 c1.push(1);
69 c2.push(2);
70 c3.push(-1).push(-2);
71 c4.push(3);
72 c5.push(-3);
73
74 this.solver.newVar(3);
75
76 try {
77 this.checkListener.addOriginalClause(c1);
78 this.checkListener.addOriginalClause(c2);
79 this.checkListener.addOriginalClause(c3);
80 this.checkListener.addOriginalClause(c4);
81 this.checkListener.addOriginalClause(c5);
82
83 this.solver.addClause(c1);
84 this.solver.addClause(c2);
85 this.solver.addClause(c3);
86 this.solver.addClause(c4);
87 this.solver.addClause(c5);
88
89 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
90
91 assertEquals(muses.size(), 2);
92
93 } catch (ContradictionException e) {
94 e.printStackTrace();
95 }
96
97 }
98
99 @Test
100 public void testVerySimpleCase() {
101 IVecInt c1 = new VecInt();
102 IVecInt c2 = new VecInt();
103
104 c1.push(1);
105 c2.push(-1);
106
107 this.solver.newVar(1);
108
109 try {
110
111 this.checkListener.addOriginalClause(c1);
112 this.checkListener.addOriginalClause(c2);
113
114 this.solver.addClause(c1);
115 this.solver.addClause(c2);
116
117 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
118
119 assertEquals(muses.size(), 1);
120
121 } catch (ContradictionException e) {
122 e.printStackTrace();
123 }
124 }
125
126 @Test
127 public void testGlobalInconsistency() throws ContradictionException,
128 TimeoutException {
129 this.solver.newVar(2);
130 IVecInt clause = new VecInt();
131 clause.push(1).push(2);
132 this.checkListener.addOriginalClause(clause);
133 this.solver.addClause(clause);
134
135 clause.clear();
136 clause.push(1).push(-2);
137 this.checkListener.addOriginalClause(clause);
138 this.solver.addClause(clause);
139
140 clause.clear();
141 clause.push(-1).push(2);
142 this.checkListener.addOriginalClause(clause);
143 this.solver.addClause(clause);
144
145 clause.clear();
146 clause.push(-1).push(-2);
147 this.checkListener.addOriginalClause(clause);
148 this.solver.addClause(clause);
149 clause.clear();
150
151 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
152 assertEquals(1, muses.size());
153 }
154
155 @Test
156 public void testGlobalInconsistencyIndex() throws ContradictionException,
157 TimeoutException {
158 this.solver.newVar(2);
159 IVecInt clause = new VecInt();
160 clause.push(1).push(2);
161 this.checkListener.addOriginalClause(clause);
162 this.solver.addClause(clause);
163 clause.clear();
164 clause.push(1).push(-2);
165 this.checkListener.addOriginalClause(clause);
166 this.solver.addClause(clause);
167 clause.clear();
168 clause.push(-1).push(2);
169 this.checkListener.addOriginalClause(clause);
170 this.solver.addClause(clause);
171 clause.clear();
172 clause.push(-1).push(-2);
173 this.checkListener.addOriginalClause(clause);
174 this.solver.addClause(clause);
175 clause.clear();
176 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
177 assertEquals(1, muses.size());
178 }
179
180 @Test
181 public void testAlmostGlobalInconsistency() throws ContradictionException,
182 TimeoutException {
183 this.solver.newVar(3);
184 IVecInt clause = new VecInt();
185 clause.push(1).push(2);
186 this.checkListener.addOriginalClause(clause);
187 IConstr c1 = this.solver.addClause(clause);
188 clause.clear();
189 clause.push(1).push(-2);
190 this.checkListener.addOriginalClause(clause);
191 IConstr c2 = this.solver.addClause(clause);
192 clause.clear();
193 clause.push(-1).push(2);
194 this.checkListener.addOriginalClause(clause);
195 IConstr c3 = this.solver.addClause(clause);
196 clause.clear();
197 clause.push(-1).push(-2);
198 this.checkListener.addOriginalClause(clause);
199 IConstr c4 = this.solver.addClause(clause);
200 clause.clear();
201 clause.push(1).push(3);
202 this.solver.addClause(clause);
203 clause.clear();
204 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
205 assertEquals(1, muses.size());
206 }
207
208 @Test
209 public void testAlmostGlobalInconsistencyIndex()
210 throws ContradictionException, TimeoutException {
211 this.solver.newVar(3);
212 IVecInt clause = new VecInt();
213 clause.push(1).push(2);
214 this.checkListener.addOriginalClause(clause);
215 this.solver.addClause(clause);
216 clause.clear();
217 clause.push(1).push(-2);
218 this.checkListener.addOriginalClause(clause);
219 this.solver.addClause(clause);
220 clause.clear();
221 clause.push(-1).push(2);
222 this.checkListener.addOriginalClause(clause);
223 this.solver.addClause(clause);
224 clause.clear();
225 clause.push(-1).push(-2);
226 this.checkListener.addOriginalClause(clause);
227 this.solver.addClause(clause);
228 clause.clear();
229 clause.push(1).push(3);
230 this.checkListener.addOriginalClause(clause);
231 this.solver.addClause(clause);
232 clause.clear();
233 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
234 assertEquals(1, muses.size());
235 }
236
237 @Test
238 public void testAlmostGlobalInconsistencyII()
239 throws ContradictionException, TimeoutException {
240 this.solver.newVar(3);
241 IVecInt clause = new VecInt();
242 clause.push(1).push(2);
243 this.checkListener.addOriginalClause(clause);
244 IConstr c1 = this.solver.addClause(clause);
245 clause.clear();
246 clause.push(1).push(-2);
247 this.checkListener.addOriginalClause(clause);
248 IConstr c2 = this.solver.addClause(clause);
249 clause.clear();
250 clause.push(1).push(3);
251 this.checkListener.addOriginalClause(clause);
252 this.solver.addClause(clause);
253 clause.clear();
254 clause.push(-1).push(2);
255 this.checkListener.addOriginalClause(clause);
256 IConstr c4 = this.solver.addClause(clause);
257 clause.clear();
258 clause.push(-1).push(-2);
259 this.checkListener.addOriginalClause(clause);
260 IConstr c5 = this.solver.addClause(clause);
261 clause.clear();
262 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
263 assertEquals(1, muses.size());
264
265 }
266
267 @Test
268 public void testAlmostGlobalInconsistencyIIIndex()
269 throws ContradictionException, TimeoutException {
270 this.solver.newVar(3);
271 IVecInt clause = new VecInt();
272 clause.push(1).push(2);
273 this.checkListener.addOriginalClause(clause);
274 this.solver.addClause(clause);
275 clause.clear();
276 clause.push(1).push(-2);
277 this.checkListener.addOriginalClause(clause);
278 this.solver.addClause(clause);
279 clause.clear();
280 clause.push(1).push(3);
281 this.checkListener.addOriginalClause(clause);
282 this.solver.addClause(clause);
283 clause.clear();
284 clause.push(-1).push(2);
285 this.checkListener.addOriginalClause(clause);
286 this.solver.addClause(clause);
287 clause.clear();
288 clause.push(-1).push(-2);
289 this.checkListener.addOriginalClause(clause);
290 this.solver.addClause(clause);
291 clause.clear();
292 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
293 assertEquals(1, muses.size());
294 }
295
296 @Test
297 public void testTheCaseOfTwoMUSes() throws ContradictionException,
298 TimeoutException {
299 this.solver.newVar(4);
300 IVecInt clause = new VecInt();
301 clause.push(1).push(2);
302 this.checkListener.addOriginalClause(clause);
303 IConstr c1 = this.solver.addClause(clause);
304 clause.clear();
305 clause.push(1).push(-2);
306 this.checkListener.addOriginalClause(clause);
307 IConstr c2 = this.solver.addClause(clause);
308 clause.clear();
309 clause.push(-1).push(3);
310 this.checkListener.addOriginalClause(clause);
311 this.solver.addClause(clause);
312 clause.clear();
313 clause.push(-1).push(-3);
314 this.checkListener.addOriginalClause(clause);
315 this.solver.addClause(clause);
316 clause.clear();
317 clause.push(-1).push(4);
318 this.checkListener.addOriginalClause(clause);
319 this.solver.addClause(clause);
320 clause.clear();
321 clause.push(-1).push(-4);
322 this.checkListener.addOriginalClause(clause);
323 this.solver.addClause(clause);
324 clause.clear();
325 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
326 assertEquals(2, muses.size());
327 }
328
329 @Test
330 public void testEclipseTestCase() throws ContradictionException,
331 TimeoutException {
332 this.solver.newVar(3);
333 IVecInt clause = new VecInt();
334 clause.push(-1);
335 this.checkListener.addOriginalClause(clause);
336 this.solver.addClause(clause);
337 clause.clear();
338 clause.push(-2).push(3);
339 this.checkListener.addOriginalClause(clause);
340 this.solver.addClause(clause);
341 clause.clear();
342 clause.push(-2).push(1);
343 this.checkListener.addOriginalClause(clause);
344 this.solver.addClause(clause);
345 clause.clear();
346 clause.push(2);
347 this.checkListener.addOriginalClause(clause);
348 this.solver.addClause(clause);
349 clause.clear();
350 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
351 assertEquals(1, muses.size());
352 }
353
354 @Test
355 public void testEclipseTestCase2() throws ContradictionException,
356 TimeoutException {
357 this.solver.newVar(4);
358 IVecInt clause = new VecInt();
359 clause.push(-1).push(2);
360 this.checkListener.addOriginalClause(clause);
361 this.solver.addClause(clause);
362 clause.clear();
363 clause.push(-1).push(3);
364 this.checkListener.addOriginalClause(clause);
365 this.solver.addClause(clause);
366 clause.clear();
367 clause.push(-2).push(-3);
368 this.checkListener.addOriginalClause(clause);
369 this.solver.addClause(clause);
370 clause.clear();
371 clause.push(-4).push(1);
372 this.checkListener.addOriginalClause(clause);
373 this.solver.addClause(clause);
374 clause.clear();
375 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
376 assertEquals(0, muses.size());
377 }
378
379 @Test
380 public void testExample1CADECedric() throws ContradictionException,
381 TimeoutException {
382 this.solver.newVar(5);
383 IVecInt clause = new VecInt();
384
385 clause.push(-4).push(5);
386 this.checkListener.addOriginalClause(clause);
387 this.solver.addClause(clause);
388 clause.clear();
389
390 clause.push(2).push(-3);
391 this.checkListener.addOriginalClause(clause);
392 this.solver.addClause(clause);
393 clause.clear();
394
395 clause.push(-4);
396 this.checkListener.addOriginalClause(clause);
397 this.solver.addClause(clause);
398 clause.clear();
399
400 clause.push(-1).push(2);
401 this.checkListener.addOriginalClause(clause);
402 this.solver.addClause(clause);
403 clause.clear();
404
405 clause.push(1);
406 this.checkListener.addOriginalClause(clause);
407 this.solver.addClause(clause);
408 clause.clear();
409
410 clause.push(1).push(-3).push(-5);
411 this.checkListener.addOriginalClause(clause);
412 this.solver.addClause(clause);
413 clause.clear();
414
415 clause.push(-1).push(3).push(4);
416 this.checkListener.addOriginalClause(clause);
417 this.solver.addClause(clause);
418 clause.clear();
419
420 clause.push(-2);
421 this.checkListener.addOriginalClause(clause);
422 this.solver.addClause(clause);
423 clause.clear();
424
425 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
426 assertEquals(2, muses.size());
427 }
428
429 @Test
430 public void testExample3CADECedric() throws ContradictionException,
431 TimeoutException {
432 this.solver.newVar(6);
433 IVecInt clause = new VecInt();
434
435 clause.push(1);
436 this.checkListener.addOriginalClause(clause);
437 this.solver.addClause(clause);
438 clause.clear();
439
440 clause.push(2).push(4);
441 this.checkListener.addOriginalClause(clause);
442 this.solver.addClause(clause);
443 clause.clear();
444
445 clause.push(-2).push(-5);
446 this.checkListener.addOriginalClause(clause);
447 this.solver.addClause(clause);
448 clause.clear();
449
450 clause.push(1).push(4);
451 this.checkListener.addOriginalClause(clause);
452 this.solver.addClause(clause);
453 clause.clear();
454
455 clause.push(2).push(-3);
456 this.checkListener.addOriginalClause(clause);
457 this.solver.addClause(clause);
458 clause.clear();
459
460 clause.push(6);
461 this.checkListener.addOriginalClause(clause);
462 this.solver.addClause(clause);
463 clause.clear();
464
465 clause.push(3).push(-4);
466 this.checkListener.addOriginalClause(clause);
467 this.solver.addClause(clause);
468 clause.clear();
469
470 clause.push(-1);
471 this.checkListener.addOriginalClause(clause);
472 this.solver.addClause(clause);
473 clause.clear();
474
475 clause.push(-2).push(-3);
476 this.checkListener.addOriginalClause(clause);
477 this.solver.addClause(clause);
478 clause.clear();
479
480 clause.push(2).push(4).push(6);
481 this.checkListener.addOriginalClause(clause);
482 this.solver.addClause(clause);
483 clause.clear();
484
485 clause.push(5);
486 this.checkListener.addOriginalClause(clause);
487 this.solver.addClause(clause);
488 clause.clear();
489
490 clause.push(-6).push(4);
491 this.checkListener.addOriginalClause(clause);
492 this.solver.addClause(clause);
493 clause.clear();
494
495 clause.push(-5).push(-6);
496 this.checkListener.addOriginalClause(clause);
497 this.solver.addClause(clause);
498 clause.clear();
499
500 clause.push(1).push(-3).push(4);
501 this.checkListener.addOriginalClause(clause);
502 this.solver.addClause(clause);
503 clause.clear();
504
505 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
506 assertEquals(9, muses.size());
507 }
508
509 @Test
510 public void testExample3IJCAICedric() throws ContradictionException,
511 TimeoutException {
512 this.solver.newVar(5);
513 IVecInt clause = new VecInt();
514
515 clause.push(4);
516 this.checkListener.addOriginalClause(clause);
517 this.solver.addClause(clause);
518 clause.clear();
519
520 clause.push(2).push(3);
521 this.checkListener.addOriginalClause(clause);
522 this.solver.addClause(clause);
523 clause.clear();
524
525 clause.push(1).push(2);
526 this.checkListener.addOriginalClause(clause);
527 this.solver.addClause(clause);
528 clause.clear();
529
530 clause.push(1).push(-3);
531 this.checkListener.addOriginalClause(clause);
532 this.solver.addClause(clause);
533 clause.clear();
534
535 clause.push(-2).push(-5);
536 this.checkListener.addOriginalClause(clause);
537 this.solver.addClause(clause);
538 clause.clear();
539
540 clause.push(-1).push(-2);
541 this.checkListener.addOriginalClause(clause);
542 this.solver.addClause(clause);
543 clause.clear();
544
545 clause.push(1).push(5);
546 this.checkListener.addOriginalClause(clause);
547 this.solver.addClause(clause);
548 clause.clear();
549
550 clause.push(-1).push(-5);
551 this.checkListener.addOriginalClause(clause);
552 this.solver.addClause(clause);
553 clause.clear();
554
555 clause.push(2).push(5);
556 this.checkListener.addOriginalClause(clause);
557 this.solver.addClause(clause);
558 clause.clear();
559
560 clause.push(-1).push(2).push(-3);
561 this.checkListener.addOriginalClause(clause);
562 this.solver.addClause(clause);
563 clause.clear();
564
565 clause.push(-1).push(2).push(-4);
566 this.checkListener.addOriginalClause(clause);
567 this.solver.addClause(clause);
568 clause.clear();
569
570 clause.push(1).push(-2).push(3);
571 this.checkListener.addOriginalClause(clause);
572 this.solver.addClause(clause);
573 clause.clear();
574
575 clause.push(1).push(-2).push(-4);
576 this.checkListener.addOriginalClause(clause);
577 this.solver.addClause(clause);
578 clause.clear();
579
580 List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
581
582 assertEquals(17, muses.size());
583 }
584
585 }