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 TestAllMUSes {
47
48 private AllMUSes allMUSes;
49 private ISolver solver;
50
51 @Before
52 public void setUp() throws Exception {
53 this.allMUSes = new AllMUSes(SolverFactory.instance());
54 this.solver = allMUSes.getSolverInstance();
55 }
56
57 @Test
58 public void testSimpleCase() {
59 IVecInt c1 = new VecInt();
60 IVecInt c2 = new VecInt();
61 IVecInt c3 = new VecInt();
62 IVecInt c4 = new VecInt();
63 IVecInt c5 = new VecInt();
64
65 c1.push(1);
66 c2.push(2);
67 c3.push(-1).push(-2);
68 c4.push(3);
69 c5.push(-3);
70
71 this.solver.newVar(3);
72
73 try {
74 this.solver.addClause(c1);
75 this.solver.addClause(c2);
76 this.solver.addClause(c3);
77 this.solver.addClause(c4);
78 this.solver.addClause(c5);
79
80 List<IVecInt> muses = allMUSes.computeAllMUSes();
81
82 assertEquals(muses.size(), 2);
83
84 } catch (ContradictionException e) {
85 e.printStackTrace();
86 }
87
88 }
89
90 @Test
91 public void testVerySimpleCase() {
92 IVecInt c1 = new VecInt();
93 IVecInt c2 = new VecInt();
94
95 c1.push(1);
96 c2.push(-1);
97
98 this.solver.newVar(1);
99
100 try {
101 this.solver.addClause(c1);
102 this.solver.addClause(c2);
103
104 List<IVecInt> muses = allMUSes.computeAllMUSes();
105
106 assertEquals(muses.size(), 1);
107
108 } catch (ContradictionException e) {
109 e.printStackTrace();
110 }
111 }
112
113 @Test
114 public void testGlobalInconsistency() throws ContradictionException,
115 TimeoutException {
116 this.solver.newVar(2);
117 IVecInt clause = new VecInt();
118 clause.push(1).push(2);
119 this.solver.addClause(clause);
120 clause.clear();
121 clause.push(1).push(-2);
122 this.solver.addClause(clause);
123 clause.clear();
124 clause.push(-1).push(2);
125 this.solver.addClause(clause);
126 clause.clear();
127 clause.push(-1).push(-2);
128 this.solver.addClause(clause);
129 clause.clear();
130 List<IVecInt> muses = allMUSes.computeAllMUSes();
131 assertEquals(1, muses.size());
132 }
133
134 @Test
135 public void testGlobalInconsistencyIndex() throws ContradictionException,
136 TimeoutException {
137 this.solver.newVar(2);
138 IVecInt clause = new VecInt();
139 clause.push(1).push(2);
140 this.solver.addClause(clause);
141 clause.clear();
142 clause.push(1).push(-2);
143 this.solver.addClause(clause);
144 clause.clear();
145 clause.push(-1).push(2);
146 this.solver.addClause(clause);
147 clause.clear();
148 clause.push(-1).push(-2);
149 this.solver.addClause(clause);
150 clause.clear();
151 List<IVecInt> muses = allMUSes.computeAllMUSes();
152 assertEquals(1, muses.size());
153 }
154
155 @Test
156 public void testAlmostGlobalInconsistency() throws ContradictionException,
157 TimeoutException {
158 this.solver.newVar(3);
159 IVecInt clause = new VecInt();
160 clause.push(1).push(2);
161 IConstr c1 = this.solver.addClause(clause);
162 clause.clear();
163 clause.push(1).push(-2);
164 IConstr c2 = this.solver.addClause(clause);
165 clause.clear();
166 clause.push(-1).push(2);
167 IConstr c3 = this.solver.addClause(clause);
168 clause.clear();
169 clause.push(-1).push(-2);
170 IConstr c4 = this.solver.addClause(clause);
171 clause.clear();
172 clause.push(1).push(3);
173 this.solver.addClause(clause);
174 clause.clear();
175 List<IVecInt> muses = allMUSes.computeAllMUSes();
176 assertEquals(1, muses.size());
177 }
178
179 @Test
180 public void testAlmostGlobalInconsistencyIndex()
181 throws ContradictionException, TimeoutException {
182 this.solver.newVar(3);
183 IVecInt clause = new VecInt();
184 clause.push(1).push(2);
185 this.solver.addClause(clause);
186 clause.clear();
187 clause.push(1).push(-2);
188 this.solver.addClause(clause);
189 clause.clear();
190 clause.push(-1).push(2);
191 this.solver.addClause(clause);
192 clause.clear();
193 clause.push(-1).push(-2);
194 this.solver.addClause(clause);
195 clause.clear();
196 clause.push(1).push(3);
197 this.solver.addClause(clause);
198 clause.clear();
199 List<IVecInt> muses = allMUSes.computeAllMUSes();
200 assertEquals(1, muses.size());
201 }
202
203 @Test
204 public void testAlmostGlobalInconsistencyII()
205 throws ContradictionException, TimeoutException {
206 this.solver.newVar(3);
207 IVecInt clause = new VecInt();
208 clause.push(1).push(2);
209 IConstr c1 = this.solver.addClause(clause);
210 clause.clear();
211 clause.push(1).push(-2);
212 IConstr c2 = this.solver.addClause(clause);
213 clause.clear();
214 clause.push(1).push(3);
215 this.solver.addClause(clause);
216 clause.clear();
217 clause.push(-1).push(2);
218 IConstr c4 = this.solver.addClause(clause);
219 clause.clear();
220 clause.push(-1).push(-2);
221 IConstr c5 = this.solver.addClause(clause);
222 clause.clear();
223 List<IVecInt> muses = allMUSes.computeAllMUSes();
224 assertEquals(1, muses.size());
225
226 }
227
228 @Test
229 public void testAlmostGlobalInconsistencyIIIndex()
230 throws ContradictionException, TimeoutException {
231 this.solver.newVar(3);
232 IVecInt clause = new VecInt();
233 clause.push(1).push(2);
234 this.solver.addClause(clause);
235 clause.clear();
236 clause.push(1).push(-2);
237 this.solver.addClause(clause);
238 clause.clear();
239 clause.push(1).push(3);
240 this.solver.addClause(clause);
241 clause.clear();
242 clause.push(-1).push(2);
243 this.solver.addClause(clause);
244 clause.clear();
245 clause.push(-1).push(-2);
246 this.solver.addClause(clause);
247 clause.clear();
248 List<IVecInt> muses = allMUSes.computeAllMUSes();
249 assertEquals(1, muses.size());
250 }
251
252 @Test
253 public void testTheCaseOfTwoMUSes() throws ContradictionException,
254 TimeoutException {
255 this.solver.newVar(4);
256 IVecInt clause = new VecInt();
257 clause.push(1).push(2);
258 IConstr c1 = this.solver.addClause(clause);
259 clause.clear();
260 clause.push(1).push(-2);
261 IConstr c2 = this.solver.addClause(clause);
262 clause.clear();
263 clause.push(-1).push(3);
264 this.solver.addClause(clause);
265 clause.clear();
266 clause.push(-1).push(-3);
267 this.solver.addClause(clause);
268 clause.clear();
269 clause.push(-1).push(4);
270 this.solver.addClause(clause);
271 clause.clear();
272 clause.push(-1).push(-4);
273 this.solver.addClause(clause);
274 clause.clear();
275 List<IVecInt> muses = allMUSes.computeAllMUSes();
276 assertEquals(2, muses.size());
277 }
278
279 @Test
280 public void testEclipseTestCase() throws ContradictionException,
281 TimeoutException {
282 this.solver.newVar(3);
283 IVecInt clause = new VecInt();
284 clause.push(-1);
285 this.solver.addClause(clause);
286 clause.clear();
287 clause.push(-2).push(3);
288 this.solver.addClause(clause);
289 clause.clear();
290 clause.push(-2).push(1);
291 this.solver.addClause(clause);
292 clause.clear();
293 clause.push(2);
294 this.solver.addClause(clause);
295 clause.clear();
296 List<IVecInt> muses = allMUSes.computeAllMUSes();
297 assertEquals(1, muses.size());
298 }
299
300 @Test
301 public void testEclipseTestCase2() throws ContradictionException,
302 TimeoutException {
303 this.solver.newVar(4);
304 IVecInt clause = new VecInt();
305 clause.push(-1).push(2);
306 this.solver.addClause(clause);
307 clause.clear();
308 clause.push(-1).push(3);
309 this.solver.addClause(clause);
310 clause.clear();
311 clause.push(-2).push(-3);
312 this.solver.addClause(clause);
313 clause.clear();
314 clause.push(-4).push(1);
315 this.solver.addClause(clause);
316 clause.clear();
317 List<IVecInt> muses = allMUSes.computeAllMUSes();
318 assertEquals(0, muses.size());
319 }
320
321 @Test
322 public void testExample1CADECedric() throws ContradictionException,
323 TimeoutException {
324 this.solver.newVar(5);
325 IVecInt clause = new VecInt();
326
327 clause.push(-4).push(5);
328 this.solver.addClause(clause);
329 clause.clear();
330
331 clause.push(2).push(-3);
332 this.solver.addClause(clause);
333 clause.clear();
334
335 clause.push(-4);
336 this.solver.addClause(clause);
337 clause.clear();
338
339 clause.push(-1).push(2);
340 this.solver.addClause(clause);
341 clause.clear();
342
343 clause.push(1);
344 this.solver.addClause(clause);
345 clause.clear();
346
347 clause.push(1).push(-3).push(-5);
348 this.solver.addClause(clause);
349 clause.clear();
350
351 clause.push(-1).push(3).push(4);
352 this.solver.addClause(clause);
353 clause.clear();
354
355 clause.push(-2);
356 this.solver.addClause(clause);
357 clause.clear();
358
359 List<IVecInt> muses = allMUSes.computeAllMUSes();
360 assertEquals(2, muses.size());
361 }
362
363 @Test
364 public void testExample3CADECedric() throws ContradictionException,
365 TimeoutException {
366 this.solver.newVar(6);
367 IVecInt clause = new VecInt();
368
369 clause.push(1);
370 this.solver.addClause(clause);
371 clause.clear();
372
373 clause.push(2).push(4);
374 this.solver.addClause(clause);
375 clause.clear();
376
377 clause.push(-2).push(-5);
378 this.solver.addClause(clause);
379 clause.clear();
380
381 clause.push(1).push(4);
382 this.solver.addClause(clause);
383 clause.clear();
384
385 clause.push(2).push(-3);
386 this.solver.addClause(clause);
387 clause.clear();
388
389 clause.push(6);
390 this.solver.addClause(clause);
391 clause.clear();
392
393 clause.push(3).push(-4);
394 this.solver.addClause(clause);
395 clause.clear();
396
397 clause.push(-1);
398 this.solver.addClause(clause);
399 clause.clear();
400
401 clause.push(-2).push(-3);
402 this.solver.addClause(clause);
403 clause.clear();
404
405 clause.push(2).push(4).push(6);
406 this.solver.addClause(clause);
407 clause.clear();
408
409 clause.push(5);
410 this.solver.addClause(clause);
411 clause.clear();
412
413 clause.push(-6).push(4);
414 this.solver.addClause(clause);
415 clause.clear();
416
417 clause.push(-5).push(-6);
418 this.solver.addClause(clause);
419 clause.clear();
420
421 clause.push(1).push(-3).push(4);
422 this.solver.addClause(clause);
423 clause.clear();
424
425 List<IVecInt> muses = allMUSes.computeAllMUSes();
426 assertEquals(9, muses.size());
427 }
428
429 @Test
430 public void testExample3IJCAICedric() throws ContradictionException,
431 TimeoutException {
432 this.solver.newVar(5);
433 IVecInt clause = new VecInt();
434
435 clause.push(4);
436 this.solver.addClause(clause);
437 clause.clear();
438
439 clause.push(2).push(3);
440 this.solver.addClause(clause);
441 clause.clear();
442
443 clause.push(1).push(2);
444 this.solver.addClause(clause);
445 clause.clear();
446
447 clause.push(1).push(-3);
448 this.solver.addClause(clause);
449 clause.clear();
450
451 clause.push(-2).push(-5);
452 this.solver.addClause(clause);
453 clause.clear();
454
455 clause.push(-1).push(-2);
456 this.solver.addClause(clause);
457 clause.clear();
458
459 clause.push(1).push(5);
460 this.solver.addClause(clause);
461 clause.clear();
462
463 clause.push(-1).push(-5);
464 this.solver.addClause(clause);
465 clause.clear();
466
467 clause.push(2).push(5);
468 this.solver.addClause(clause);
469 clause.clear();
470
471 clause.push(-1).push(2).push(-3);
472 this.solver.addClause(clause);
473 clause.clear();
474
475 clause.push(-1).push(2).push(-4);
476 this.solver.addClause(clause);
477 clause.clear();
478
479 clause.push(1).push(-2).push(3);
480 this.solver.addClause(clause);
481 clause.clear();
482
483 clause.push(1).push(-2).push(-4);
484 this.solver.addClause(clause);
485 clause.clear();
486
487 List<IVecInt> muses = allMUSes.computeAllMUSes();
488
489 assertEquals(17, muses.size());
490 }
491
492 }