From 3964fe751c0701f47d8fedf4faefdbdcebbb98a2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Sat, 25 Oct 2025 14:36:27 +0200 Subject: [PATCH 01/11] Refactored pickBranchLit-related functions and further divided to allow more callbacks --- src/parallel/ScatterSplitter.cc | 4 +- src/parallel/ScatterSplitter.h | 4 +- src/smtsolvers/CoreSMTSolver.cc | 88 +++++++++++++++++--------------- src/smtsolvers/CoreSMTSolver.h | 12 +++-- src/smtsolvers/GhostSMTSolver.cc | 32 +----------- src/smtsolvers/GhostSMTSolver.h | 2 - 6 files changed, 59 insertions(+), 83 deletions(-) diff --git a/src/parallel/ScatterSplitter.cc b/src/parallel/ScatterSplitter.cc index 8c4b08e62..7d5582012 100644 --- a/src/parallel/ScatterSplitter.cc +++ b/src/parallel/ScatterSplitter.cc @@ -17,13 +17,13 @@ ScatterSplitter::ScatterSplitter(SMTConfig & c, THandler & t, PTPLib::net::Chann , nodeCounter (t.getLogic(), PTPLib::common::STATS.MAX_SIZE) {} -bool ScatterSplitter::branchLitRandom() { +bool ScatterSplitter::randomBranchingCond() { return ((not splitContext.isInSplittingCycle() and drand(random_seed) < random_var_freq) or (splitContext.isInSplittingCycle() and splitContext.preferRandom())) and not order_heap.empty(); } -Var ScatterSplitter::doActivityDecision() { +Var ScatterSplitter::pickActivityBranchVar() { vec discarded; Var next = var_Undef; while (next == var_Undef || value(next) != l_Undef || !decision[next]) { diff --git a/src/parallel/ScatterSplitter.h b/src/parallel/ScatterSplitter.h index e6964508d..543cca52e 100644 --- a/src/parallel/ScatterSplitter.h +++ b/src/parallel/ScatterSplitter.h @@ -63,8 +63,8 @@ class ScatterSplitter : public SimpSMTSolver, public Splitter { bool isAssumptionVar(Var v) const { return assumptionVars.find(v) != assumptionVars.end(); } lbool solve_() override; - bool branchLitRandom() override; - Var doActivityDecision() override; + bool randomBranchingCond() override; + Var pickActivityBranchVar() override; bool okContinue() const override; ConsistencyAction notifyConsistency() override; void notifyEnd() override; diff --git a/src/smtsolvers/CoreSMTSolver.cc b/src/smtsolvers/CoreSMTSolver.cc index 070ecffd0..29eec0b29 100644 --- a/src/smtsolvers/CoreSMTSolver.cc +++ b/src/smtsolvers/CoreSMTSolver.cc @@ -499,69 +499,73 @@ void CoreSMTSolver::cancelUntilVarTempDone( ) } } -Var CoreSMTSolver::doRandomDecision() { - Var next = var_Undef; - if (branchLitRandom()) { - next = order_heap[irand(random_seed,order_heap.size())]; - if (value(next) == l_Undef && decision[next]) - rnd_decisions++; - } - return next; +bool CoreSMTSolver::randomBranchingCond() { + return drand(random_seed) < random_var_freq && !order_heap.empty(); } -bool CoreSMTSolver::branchLitRandom() { - return drand(random_seed) < random_var_freq && !order_heap.empty(); +Var CoreSMTSolver::pickRandomBranchVar() { + if (not randomBranchingCond()) { return var_Undef; } + + Var next = order_heap[irand(random_seed,order_heap.size())]; + if (value(next) == l_Undef && decision[next]) { rnd_decisions++; } + return next; } -Var CoreSMTSolver::doActivityDecision() { +Var CoreSMTSolver::pickActivityBranchVar() { Var next = var_Undef; while (next == var_Undef || value(next) != l_Undef || !decision[next]) { - if (order_heap.empty()) { - next = var_Undef; - break; - } else { - next = order_heap.removeMin(); - } + if (order_heap.empty()) { return var_Undef; } + next = order_heap.removeMin(); + } + return next; +} + +Var CoreSMTSolver::pickBranchVar() { + // Pick a variable either randomly or based on activity + Var next = pickRandomBranchVar(); + // Activity based decision + if (next == var_Undef || value(next) != l_Undef || !decision[next]) { + next = pickActivityBranchVar(); } + return next; } -Lit CoreSMTSolver::choosePolarity(Var next) { +bool CoreSMTSolver::pickBranchSignFor(Var next) { assert(next != var_Undef); - bool sign = false; - bool use_theory_suggested_polarity = config.use_theory_polarity_suggestion(); - if (use_theory_suggested_polarity && next != var_Undef && theory_handler.isDeclared(next)) { + assert(value(next) == l_Undef); + assert(decision[next]); + + bool const use_theory_suggested_polarity = config.use_theory_polarity_suggestion(); + if (use_theory_suggested_polarity && theory_handler.isDeclared(next)) { lbool suggestion = theory_handler.getSolverHandler().getPolaritySuggestion(theory_handler.varToTerm(next)); if (suggestion != l_Undef) { - sign = (suggestion != l_True); - return mkLit(next, sign); + return suggestion != l_True; } } - sign = (savedPolarity[next] == flipState); - return mkLit(next, sign); -} - -//================================================================================================= -// Major methods: - -Lit CoreSMTSolver::pickBranchLit() -{ - Var next = var_Undef; - // Pick a variable either randomly or based on activity - next = doRandomDecision(); - // Activity based decision - if (next == var_Undef || value(next) != l_Undef || !decision[next]) - next = doActivityDecision(); + return savedPolarity[next] == flipState; +} - if (next == var_Undef) // All variables are assigned - return lit_Undef; +Lit CoreSMTSolver::mkBranchLitFrom(Var next) { + assert(next != var_Undef); + assert(value(next) == l_Undef); + assert(decision[next]); - // Return the literal with the chosen polarity - return choosePolarity(next); + bool const sign = pickBranchSignFor(next); + return mkLit(next, sign); +} +Lit CoreSMTSolver::pickBranchLit() { + Var next = pickBranchVar(); + // All variables are assigned + if (next == var_Undef) { return lit_Undef; } + return mkBranchLitFrom(next); } +//================================================================================================= +// Major methods: + /*_________________________________________________________________________________________________ | | analyze : (confl : CRef) (out_learnt : vec&) (out_btlevel : int&) -> [void] diff --git a/src/smtsolvers/CoreSMTSolver.h b/src/smtsolvers/CoreSMTSolver.h index c27c1ee56..e779d28bc 100644 --- a/src/smtsolvers/CoreSMTSolver.h +++ b/src/smtsolvers/CoreSMTSolver.h @@ -357,11 +357,13 @@ class CoreSMTSolver // virtual lbool solve_ (); // Main solve method (assumptions given in 'assumptions'). void insertVarOrder (Var x); // Insert a variable in the decision order priority queue. - Var doRandomDecision(); - Lit choosePolarity(Var next); - virtual Var doActivityDecision(); - virtual bool branchLitRandom(); - virtual Lit pickBranchLit (); // Return the next decision variable. + virtual bool randomBranchingCond(); + virtual Var pickRandomBranchVar(); + virtual Var pickActivityBranchVar(); + virtual Var pickBranchVar(); + virtual bool pickBranchSignFor(Var); + virtual Lit mkBranchLitFrom(Var); + virtual Lit pickBranchLit(); // Return the next decision variable. virtual void newDecisionLevel (); // Begins a new decision level. void uncheckedEnqueue (Lit p, CRef from = CRef_Undef); // Enqueue a literal. Assumes value of literal is undefined. bool enqueue (Lit p, CRef from = CRef_Undef); // Test if fact 'p' contradicts current state, enqueue otherwise. diff --git a/src/smtsolvers/GhostSMTSolver.cc b/src/smtsolvers/GhostSMTSolver.cc index e9e894522..6ebb6e162 100644 --- a/src/smtsolvers/GhostSMTSolver.cc +++ b/src/smtsolvers/GhostSMTSolver.cc @@ -87,34 +87,6 @@ GhostSMTSolver::newVar(bool dvar) return v; } -// Random decision: -Var -GhostSMTSolver::pickRandomBranchVar() { - if (order_heap.empty()) - return var_Undef; - else - return order_heap[irand(random_seed,order_heap.size())]; -} - -// Activity based decision: -Var -GhostSMTSolver::pickBranchVar() { - Var next; - while (true) { - if (order_heap.empty()) { - next = var_Undef; - break; - } - else { - next = order_heap.removeMin(); - } - if (value(next) == l_Undef && decision[next]) - break; - } - assert(next == var_Undef || value(next) == l_Undef); - return next; -} - Lit GhostSMTSolver::pickBranchPolarity(Var next) { assert(next != var_Undef); @@ -154,7 +126,7 @@ GhostSMTSolver::pickBranchLit() { StopWatch s(branchTimer); #endif - if ((drand(random_seed) < random_var_freq) && !order_heap.empty()) { + { Var v = pickRandomBranchVar(); if (v != var_Undef && value(v) == l_Undef) { Lit l = pickBranchPolarity(v); @@ -167,7 +139,7 @@ GhostSMTSolver::pickBranchLit() { Lit l = lit_Undef; while (l == lit_Undef) { - Var v = pickBranchVar(); + Var v = pickActivityBranchVar(); if (v == var_Undef) break; // There are no free vars l = pickBranchPolarity(v); diff --git a/src/smtsolvers/GhostSMTSolver.h b/src/smtsolvers/GhostSMTSolver.h index 49e5b330b..56772ed22 100644 --- a/src/smtsolvers/GhostSMTSolver.h +++ b/src/smtsolvers/GhostSMTSolver.h @@ -15,8 +15,6 @@ class GhostSMTSolver : public SimpSMTSolver std::vector> thLitToClauses; vec ghostTrail; vec ghostTrailLim; - Var pickBranchVar(); - Var pickRandomBranchVar(); Lit pickBranchPolarity(Var v); bool isGhost(Lit l); protected: From a2eb81da713eda7643810f3fa942638787559793 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Sat, 25 Oct 2025 17:06:38 +0200 Subject: [PATCH 02/11] Added isValidBranchVar helper function --- src/parallel/ScatterSplitter.cc | 2 +- src/smtsolvers/CoreSMTSolver.cc | 25 +++++++++---------------- src/smtsolvers/CoreSMTSolver.h | 1 + 3 files changed, 11 insertions(+), 17 deletions(-) diff --git a/src/parallel/ScatterSplitter.cc b/src/parallel/ScatterSplitter.cc index 7d5582012..f016dd472 100644 --- a/src/parallel/ScatterSplitter.cc +++ b/src/parallel/ScatterSplitter.cc @@ -26,7 +26,7 @@ bool ScatterSplitter::randomBranchingCond() { Var ScatterSplitter::pickActivityBranchVar() { vec discarded; Var next = var_Undef; - while (next == var_Undef || value(next) != l_Undef || !decision[next]) { + while (not isValidBranchVar(next)) { if (order_heap.empty()) { if (discarded.size() > 0) { assert(splitContext.isInSplittingCycle()); diff --git a/src/smtsolvers/CoreSMTSolver.cc b/src/smtsolvers/CoreSMTSolver.cc index 29eec0b29..8786abcbe 100644 --- a/src/smtsolvers/CoreSMTSolver.cc +++ b/src/smtsolvers/CoreSMTSolver.cc @@ -507,13 +507,14 @@ Var CoreSMTSolver::pickRandomBranchVar() { if (not randomBranchingCond()) { return var_Undef; } Var next = order_heap[irand(random_seed,order_heap.size())]; - if (value(next) == l_Undef && decision[next]) { rnd_decisions++; } + assert(next != var_Undef); + if (isValidBranchVar(next)) { rnd_decisions++; } return next; } Var CoreSMTSolver::pickActivityBranchVar() { Var next = var_Undef; - while (next == var_Undef || value(next) != l_Undef || !decision[next]) { + while (not isValidBranchVar(next)) { if (order_heap.empty()) { return var_Undef; } next = order_heap.removeMin(); } @@ -522,19 +523,14 @@ Var CoreSMTSolver::pickActivityBranchVar() { Var CoreSMTSolver::pickBranchVar() { // Pick a variable either randomly or based on activity - Var next = pickRandomBranchVar(); - // Activity based decision - if (next == var_Undef || value(next) != l_Undef || !decision[next]) { - next = pickActivityBranchVar(); - } + if (Var next = pickRandomBranchVar(); isValidBranchVar(next)) { return next; } - return next; + // Activity based decision + return pickActivityBranchVar(); } bool CoreSMTSolver::pickBranchSignFor(Var next) { - assert(next != var_Undef); - assert(value(next) == l_Undef); - assert(decision[next]); + assert(isValidBranchVar(next)); bool const use_theory_suggested_polarity = config.use_theory_polarity_suggestion(); if (use_theory_suggested_polarity && theory_handler.isDeclared(next)) { @@ -548,10 +544,7 @@ bool CoreSMTSolver::pickBranchSignFor(Var next) { } Lit CoreSMTSolver::mkBranchLitFrom(Var next) { - assert(next != var_Undef); - assert(value(next) == l_Undef); - assert(decision[next]); - + assert(isValidBranchVar(next)); bool const sign = pickBranchSignFor(next); return mkLit(next, sign); } @@ -1209,7 +1202,7 @@ void CoreSMTSolver::rebuildOrderHeap() { vec vs; for (Var v = 0; v < nVars(); v++) - if (decision[v] && value(v) == l_Undef) + if (isValidBranchVar(v)) vs.push(v); order_heap.build(vs); } diff --git a/src/smtsolvers/CoreSMTSolver.h b/src/smtsolvers/CoreSMTSolver.h index e779d28bc..5ad8fb8f4 100644 --- a/src/smtsolvers/CoreSMTSolver.h +++ b/src/smtsolvers/CoreSMTSolver.h @@ -357,6 +357,7 @@ class CoreSMTSolver // virtual lbool solve_ (); // Main solve method (assumptions given in 'assumptions'). void insertVarOrder (Var x); // Insert a variable in the decision order priority queue. + inline bool isValidBranchVar(Var x) const { return x != var_Undef and value(x) == l_Undef and decision[x]; } virtual bool randomBranchingCond(); virtual Var pickRandomBranchVar(); virtual Var pickActivityBranchVar(); From 76ccdedd1f42d78989837c7acd27a0c51d509da7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Sat, 25 Oct 2025 17:08:03 +0200 Subject: [PATCH 03/11] Added dummy user callbacks into the pickBranchLit pipeline --- src/smtsolvers/CoreSMTSolver.cc | 9 +++++++++ src/smtsolvers/CoreSMTSolver.h | 3 +++ 2 files changed, 12 insertions(+) diff --git a/src/smtsolvers/CoreSMTSolver.cc b/src/smtsolvers/CoreSMTSolver.cc index 8786abcbe..55ae12ba8 100644 --- a/src/smtsolvers/CoreSMTSolver.cc +++ b/src/smtsolvers/CoreSMTSolver.cc @@ -522,6 +522,8 @@ Var CoreSMTSolver::pickActivityBranchVar() { } Var CoreSMTSolver::pickBranchVar() { + if (Var next = pickUserBranchVar(); next != var_Undef) { return next; } + // Pick a variable either randomly or based on activity if (Var next = pickRandomBranchVar(); isValidBranchVar(next)) { return next; } @@ -532,6 +534,8 @@ Var CoreSMTSolver::pickBranchVar() { bool CoreSMTSolver::pickBranchSignFor(Var next) { assert(isValidBranchVar(next)); + if (lbool sign = pickUserBranchSignFor(next); sign != l_Undef) { return sign != l_True; } + bool const use_theory_suggested_polarity = config.use_theory_polarity_suggestion(); if (use_theory_suggested_polarity && theory_handler.isDeclared(next)) { lbool suggestion = theory_handler.getSolverHandler().getPolaritySuggestion(theory_handler.varToTerm(next)); @@ -550,6 +554,11 @@ Lit CoreSMTSolver::mkBranchLitFrom(Var next) { } Lit CoreSMTSolver::pickBranchLit() { + if (Lit l = pickUserBranchLit(); l != lit_Undef) { + assert(isValidBranchVar(var(l))); + return l; + } + Var next = pickBranchVar(); // All variables are assigned if (next == var_Undef) { return lit_Undef; } diff --git a/src/smtsolvers/CoreSMTSolver.h b/src/smtsolvers/CoreSMTSolver.h index 5ad8fb8f4..8e4961a45 100644 --- a/src/smtsolvers/CoreSMTSolver.h +++ b/src/smtsolvers/CoreSMTSolver.h @@ -358,12 +358,15 @@ class CoreSMTSolver virtual lbool solve_ (); // Main solve method (assumptions given in 'assumptions'). void insertVarOrder (Var x); // Insert a variable in the decision order priority queue. inline bool isValidBranchVar(Var x) const { return x != var_Undef and value(x) == l_Undef and decision[x]; } + virtual Var pickUserBranchVar() { return var_Undef; } virtual bool randomBranchingCond(); virtual Var pickRandomBranchVar(); virtual Var pickActivityBranchVar(); virtual Var pickBranchVar(); + virtual lbool pickUserBranchSignFor(Var) { return l_Undef; } virtual bool pickBranchSignFor(Var); virtual Lit mkBranchLitFrom(Var); + virtual Lit pickUserBranchLit() { return lit_Undef; } virtual Lit pickBranchLit(); // Return the next decision variable. virtual void newDecisionLevel (); // Begins a new decision level. void uncheckedEnqueue (Lit p, CRef from = CRef_Undef); // Enqueue a literal. Assumes value of literal is undefined. From e11e88cfcba694e0f382cbb84cc7279cffd9ecfc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Thu, 6 Nov 2025 11:24:40 +0100 Subject: [PATCH 04/11] Split simplifyFormulas to sub-functions This makes the preprocessing more maintainable, allows overriding particular parts and also allows preprocessing single formulas without necessarily giving them to the SMT solver Also added `preprocess` as an alias to `simplifyFormulas` --- src/api/MainSolver.cc | 155 ++++++++++++++++++++++++++++++------------ src/api/MainSolver.h | 10 +++ 2 files changed, 121 insertions(+), 44 deletions(-) diff --git a/src/api/MainSolver.cc b/src/api/MainSolver.cc index 781602091..ac0d9c6fa 100644 --- a/src/api/MainSolver.cc +++ b/src/api/MainSolver.cc @@ -140,63 +140,126 @@ bool MainSolver::tryAddTermNameFor(PTRef fla, std::string const & name) { sstat MainSolver::simplifyFormulas() { status = s_Undef; - for (std::size_t i = firstNotSimplifiedFrame; i < frames.frameCount() && status != s_False; i++) { + for (std::size_t i = firstNotSimplifiedFrame; i < frames.frameCount(); ++i) { + auto & frame = frames[i]; + FrameId const frameId = frame.getId(); PreprocessingContext context{.frameCount = i, .perPartition = trackPartitions()}; preprocessor.prepareForProcessingFrame(i); firstNotSimplifiedFrame = i + 1; - if (context.perPartition) { - vec frameFormulas; - for (PTRef fla : frames[i].formulas) { - PTRef processed = theory->preprocessAfterSubstitutions(fla, context); - pmanager.transferPartitionMembership(fla, processed); - frameFormulas.push(processed); - preprocessor.addPreprocessedFormula(processed); - } - if (frameFormulas.size() == 0 or std::all_of(frameFormulas.begin(), frameFormulas.end(), - [&](PTRef fla) { return fla == logic.getTerm_true(); })) { - continue; - } - theory->afterPreprocessing(preprocessor.getPreprocessedFormulas()); - for (PTRef fla : frameFormulas) { - if (fla == logic.getTerm_true()) { continue; } - assert(pmanager.getPartitionIndex(fla) != -1); - // Optimize the dag for cnfization - if (logic.isBooleanOperator(fla)) { - PTRef old = fla; - fla = rewriteMaxArity(fla); - pmanager.transferPartitionMembership(old, fla); - } - assert(pmanager.getPartitionIndex(fla) != -1); - pmanager.propagatePartitionMask(fla); - status = giveToSolver(fla, frames[i].getId()); - if (status == s_False) { break; } - } + + if (not context.perPartition) { + PTRef frameFormula = preprocessFormulasDefault(frame.formulas, context); + status = giveToSolver(frameFormula, frameId); } else { - PTRef frameFormula = logic.mkAnd(frames[i].formulas); - if (context.frameCount > 0) { frameFormula = applyLearntSubstitutions(frameFormula); } - frameFormula = theory->preprocessBeforeSubstitutions(frameFormula, context); - frameFormula = substitutionPass(frameFormula, context); - frameFormula = theory->preprocessAfterSubstitutions(frameFormula, context); - - if (logic.isFalse(frameFormula)) { - giveToSolver(logic.getTerm_false(), frames[i].getId()); - status = s_False; - break; + vec processedFormulas = preprocessFormulasPerPartition(frame.formulas, context); + for (PTRef fla : processedFormulas) { + status = giveToSolver(fla, frameId); + if (status == s_False) { break; } } - preprocessor.addPreprocessedFormula(frameFormula); - theory->afterPreprocessing(preprocessor.getPreprocessedFormulas()); - // Optimize the dag for cnfization - if (logic.isBooleanOperator(frameFormula)) { frameFormula = rewriteMaxArity(frameFormula); } - status = giveToSolver(frameFormula, frames[i].getId()); } + if (status == s_False) { break; } } + if (status == s_False) { assert(firstNotSimplifiedFrame > 0); rememberUnsatFrame(firstNotSimplifiedFrame - 1); } + return status; } +PTRef MainSolver::preprocessFormulasDefault(vec const & frameFormulas, PreprocessingContext const & context) { + assert(not context.perPartition); + + if (frameFormulas.size() == 0) { return logic.getTerm_true(); } + + PTRef frameFormula = logic.mkAnd(frameFormulas); + return preprocessFormula(frameFormula, context); +} + +vec MainSolver::preprocessFormulasPerPartition(vec const & frameFormulas, + PreprocessingContext const & context) { + assert(context.perPartition); + + if (frameFormulas.size() == 0) { return {}; } + + vec processedFormulas; + for (PTRef fla : frameFormulas) { + PTRef processed = preprocessFormulaBeforeFinalTheoryPreprocessing(fla, context); + processedFormulas.push(processed); + } + + assert(processedFormulas.size() == frameFormulas.size()); + assert(processedFormulas.size() > 0); + if (std::all_of(processedFormulas.begin(), processedFormulas.end(), + [&](PTRef fla) { return fla == logic.getTerm_true(); })) { + return {}; + } + + preprocessFormulaDoFinalTheoryPreprocessing(context); + + for (PTRef & fla : processedFormulas) { + if (fla == logic.getTerm_true()) { continue; } + fla = preprocessFormulaAfterFinalTheoryPreprocessing(fla, context); + } + + return processedFormulas; +} + +PTRef MainSolver::preprocessFormula(PTRef fla, PreprocessingContext const & context) { + PTRef processed = preprocessFormulaBeforeFinalTheoryPreprocessing(fla, context); + preprocessFormulaDoFinalTheoryPreprocessing(context); + processed = preprocessFormulaAfterFinalTheoryPreprocessing(processed, context); + return processed; +} + +PTRef MainSolver::preprocessFormulaBeforeFinalTheoryPreprocessing(PTRef fla, PreprocessingContext const & context) { + bool const perPartition = context.perPartition; + PTRef processed = fla; + + if (not perPartition) { + if (context.frameCount > 0) { processed = applyLearntSubstitutions(processed); } + processed = theory->preprocessBeforeSubstitutions(processed, context); + processed = substitutionPass(processed, context); + } + + processed = theory->preprocessAfterSubstitutions(processed, context); + + if (perPartition) { + pmanager.transferPartitionMembership(fla, processed); + } else if (logic.isFalse(processed)) { + return logic.getTerm_false(); + } + + preprocessor.addPreprocessedFormula(processed); + + return processed; +} + +void MainSolver::preprocessFormulaDoFinalTheoryPreprocessing(PreprocessingContext const &) { + theory->afterPreprocessing(preprocessor.getPreprocessedFormulas()); +} + +PTRef MainSolver::preprocessFormulaAfterFinalTheoryPreprocessing(PTRef fla, PreprocessingContext const & context) { + bool const perPartition = context.perPartition; + PTRef processed = fla; + + assert(not perPartition or pmanager.getPartitionIndex(processed) != -1); + + // Optimize the dag for cnfization + if (logic.isBooleanOperator(processed)) { + processed = rewriteMaxArity(processed); + if (perPartition) { pmanager.transferPartitionMembership(fla, processed); } + } + + if (perPartition) { + assert(pmanager.getPartitionIndex(processed) != -1); + pmanager.propagatePartitionMask(processed); + } + + return processed; +} + vec MainSolver::getCurrentAssertions() const { vec assertions; size_t const cnt = frames.frameCount(); @@ -312,11 +375,15 @@ sstat MainSolver::giveToSolver(PTRef root, FrameId push_id) { std::vector> clauses; void operator()(vec && c) override { clauses.push_back(std::move(c)); } }; + + if (root == logic.getTerm_true()) { return s_Undef; } + ClauseCallBack callBack; ts.setClauseCallBack(&callBack); ts.Cnfizer::cnfize(root, push_id); bool const keepPartitionsSeparate = trackPartitions(); - Lit frameLit = push_id == 0 ? Lit{} : term_mapper->getOrCreateLit(frameTerms[push_id]); + Lit frameLit; + if (push_id != 0) { frameLit = term_mapper->getOrCreateLit(frameTerms[push_id]); } int partitionIndex = keepPartitionsSeparate ? pmanager.getPartitionIndex(root) : -1; for (auto & clause : callBack.clauses) { if (push_id != 0) { clause.push(frameLit); } diff --git a/src/api/MainSolver.h b/src/api/MainSolver.h index 8cc3fc2ed..4e91a7572 100644 --- a/src/api/MainSolver.h +++ b/src/api/MainSolver.h @@ -105,6 +105,8 @@ class MainSolver { // Simplify formulas until all are simplified or the instance is detected unsat // Skip assertion levels that have already been simplified sstat simplifyFormulas(); + // Alias for `simplifyFormulas`, reserved for future use + sstat preprocess() { return simplifyFormulas(); } [[nodiscard]] sstat getStatus() const { return status; } @@ -289,6 +291,14 @@ class MainSolver { inline bool trackPartitions() const; + virtual PTRef preprocessFormulasDefault(vec const & frameFormulas, PreprocessingContext const &); + virtual vec preprocessFormulasPerPartition(vec const & frameFormulas, PreprocessingContext const &); + + virtual PTRef preprocessFormula(PTRef, PreprocessingContext const &); + virtual PTRef preprocessFormulaBeforeFinalTheoryPreprocessing(PTRef, PreprocessingContext const &); + virtual void preprocessFormulaDoFinalTheoryPreprocessing(PreprocessingContext const &); + virtual PTRef preprocessFormulaAfterFinalTheoryPreprocessing(PTRef, PreprocessingContext const &); + PTRef rewriteMaxArity(PTRef root); virtual sstat solve_(vec const & enabledFrames); From 42eb1fc59a15bb38020307ab6e8126719cc5ba01 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Thu, 30 Oct 2025 10:00:28 +0100 Subject: [PATCH 05/11] Implemented decision preferences of literals or previously asserted terms --- src/api/MainSolver.cc | 55 +++++++++++++++++++++++++++++ src/api/MainSolver.h | 12 +++++++ src/logics/Logic.cc | 20 ++++++++--- src/logics/Logic.h | 2 ++ src/smtsolvers/CoreSMTSolver.cc | 61 +++++++++++++++++++-------------- src/smtsolvers/CoreSMTSolver.h | 10 +++++- 6 files changed, 129 insertions(+), 31 deletions(-) diff --git a/src/api/MainSolver.cc b/src/api/MainSolver.cc index ac0d9c6fa..f896b8201 100644 --- a/src/api/MainSolver.cc +++ b/src/api/MainSolver.cc @@ -73,6 +73,7 @@ void MainSolver::push() { bool alreadyUnsat = isLastFrameUnsat(); frames.push(); preprocessor.push(); + decisionPreferences.pushScope(); frameTerms.push(newFrameTerm(frames.last().getId())); termNames.pushScope(); if (alreadyUnsat) { rememberLastFrameUnsat(); } @@ -92,7 +93,15 @@ bool MainSolver::pop() { } frames.pop(); preprocessor.pop(); + assert(decisionPreferences.size() >= smt_solver->userBranchLitsSize()); + if (decisionPreferences.size() == smt_solver->userBranchLitsSize()) { + decisionPreferences.popScope([this](PTRef /*pref*/) { smt_solver->popUserBranchLit(); }); + } else { + decisionPreferences.popScope(); + } + assert(decisionPreferences.size() >= smt_solver->userBranchLitsSize()); termNames.popScope(); + // goes back to frames.frameCount()-1 only if a formula is added via insertFormula firstNotSimplifiedFrame = std::min(firstNotSimplifiedFrame, frames.frameCount()); if (not isLastFrameUnsat()) { getSMTSolver().restoreOK(); } return true; @@ -138,6 +147,22 @@ bool MainSolver::tryAddTermNameFor(PTRef fla, std::string const & name) { return termNames.tryInsert(name, fla); } +void MainSolver::addDecisionPreference(PTRef fla) { + if (logic.getSortRef(fla) != logic.getSort_bool()) { + throw ApiException("Decision preference sort must be Bool, got " + logic.sortToString(logic.getSortRef(fla))); + } + + if (logic.isConstant(fla)) { return; } + + decisionPreferences.push(fla); +} + +void MainSolver::resetDecisionPreferences() { + decisionPreferences.clear(); + + smt_solver->clearUserBranchLits(); +} + sstat MainSolver::simplifyFormulas() { status = s_Undef; for (std::size_t i = firstNotSimplifiedFrame; i < frames.frameCount(); ++i) { @@ -158,6 +183,10 @@ sstat MainSolver::simplifyFormulas() { } } if (status == s_False) { break; } + + for (PTRef pref : decisionPreferences.scope(i)) { + giveDecisionPreferenceToSMTSolver(pref); + } } if (status == s_False) { @@ -318,6 +347,26 @@ PTRef MainSolver::rewriteMaxArity(PTRef root) { return opensmt::rewriteMaxArityClassic(logic, root); } +void MainSolver::giveDecisionPreferenceToSMTSolver(PTRef pref) { + assert(logic.getSortRef(pref) == logic.getSort_bool()); + assert(not logic.isConstant(pref)); + + Lit l; + if (logic.isBoolVarLiteral(pref)) { + l = term_mapper->getOrCreateLit(pref); + Var v = var(l); + smt_solver->addVar(v); + } else { + // Ignores substitutions .. + assert(term_mapper->hasLit(pref)); + l = term_mapper->getLit(pref); + } + assert(term_mapper->getLit(pref) == l); + assert(term_mapper->getVar(pref) == var(l)); + + decisionPreferenceToLitMap.emplace(pref, l); +} + std::unique_ptr MainSolver::getModel() { if (!config.produce_models()) { throw ApiException("Producing models is not enabled"); } if (status != s_True) { throw ApiException("Model cannot be created if solver is not in SAT state"); } @@ -430,6 +479,12 @@ sstat MainSolver::check() { sstat MainSolver::solve() { if (!smt_solver->isOK()) { return s_False; } + smt_solver->clearUserBranchLits(); + for (PTRef pref : decisionPreferences) { + //++ probably just use vector + smt_solver->pushUserBranchLit(decisionPreferenceToLitMap[pref]); + } + // FIXME: Find a better way to deal with Bools in UF for (PTRef tr : logic.propFormulasAppearingInUF) { Lit l = term_mapper->getOrCreateLit(tr); diff --git a/src/api/MainSolver.h b/src/api/MainSolver.h index 4e91a7572..022de4fef 100644 --- a/src/api/MainSolver.h +++ b/src/api/MainSolver.h @@ -20,6 +20,7 @@ #include #include +#include namespace opensmt { class Logic; @@ -98,6 +99,12 @@ class MainSolver { // Try add a unique name for a term already included in the assertions bool tryAddTermNameFor(PTRef, std::string const & name); + // Instructs the solver to assign the formula to true when it arrives at a decision point + // The preference is appended to the list of preferences, favoring the earlier entries first + // It complies with the assertion stack + void addDecisionPreference(PTRef fla); + void resetDecisionPreferences(); + void initialize(); virtual sstat check(); // A wrapper for solve which simplifies the loaded formulas and initializes the solvers @@ -301,6 +308,8 @@ class MainSolver { PTRef rewriteMaxArity(PTRef root); + void giveDecisionPreferenceToSMTSolver(PTRef); + virtual sstat solve_(vec const & enabledFrames); sstat giveToSolver(PTRef root, FrameId push_id); @@ -313,6 +322,9 @@ class MainSolver { AssertionStack frames; + ScopedVector decisionPreferences; + std::unordered_map decisionPreferenceToLitMap; + sstat status = s_Undef; // The status of the last solver call private: diff --git a/src/logics/Logic.cc b/src/logics/Logic.cc index 3487fd902..99b48707f 100644 --- a/src/logics/Logic.cc +++ b/src/logics/Logic.cc @@ -880,12 +880,22 @@ bool Logic::isAtom(PTRef r) const { return false; } +namespace { + bool isLiteralTp(Logic const & logic, auto logicPredicate, PTRef tr) { + if ((logic.*logicPredicate)(tr)) { return true; } + if (not logic.isNot(tr)) { return false; } + auto & term = logic.getPterm(tr); + assert(term.size() == 1); + return (logic.*logicPredicate)(term[0]); + } +} // namespace + bool Logic::isLiteral(PTRef tr) const { - if (isAtom(tr)) { return true; } - if (not isNot(tr)) { return false; } - auto & term = getPterm(tr); - assert(term.size() == 1); - return isAtom(term[0]); + return isLiteralTp(*this, &Logic::isAtom, tr); +} + +bool Logic::isBoolVarLiteral(PTRef tr) const { + return isLiteralTp(*this, &Logic::isBoolVar, tr); } // diff --git a/src/logics/Logic.h b/src/logics/Logic.h index c731d829b..0607df1c9 100644 --- a/src/logics/Logic.h +++ b/src/logics/Logic.h @@ -286,6 +286,8 @@ class Logic { virtual bool isAtom(PTRef tr) const; // An atom or its negation bool isLiteral(PTRef tr) const; + // BoolVar or its negation + bool isBoolVarLiteral(PTRef tr) const; // Check if term is an uninterpreted predicate. bool isInterpreted(SymRef sr) const { return sym_store.isInterpreted(sr); } virtual bool isUP(PTRef) const; diff --git a/src/smtsolvers/CoreSMTSolver.cc b/src/smtsolvers/CoreSMTSolver.cc index 55ae12ba8..7865f9103 100644 --- a/src/smtsolvers/CoreSMTSolver.cc +++ b/src/smtsolvers/CoreSMTSolver.cc @@ -553,6 +553,18 @@ Lit CoreSMTSolver::mkBranchLitFrom(Var next) { return mkLit(next, sign); } +Lit CoreSMTSolver::pickUserBranchLit() { + // TODO: remember the last position that can be reused until a backtrack or reset + for (Lit l : userBranchLits) { + assert(l != lit_Undef); + Var const x = var(l); + assert(x != var_Undef); + if (isValidBranchVar(x)) { return l; } + } + + return lit_Undef; +} + Lit CoreSMTSolver::pickBranchLit() { if (Lit l = pickUserBranchLit(); l != lit_Undef) { assert(isValidBranchVar(var(l))); @@ -1621,46 +1633,45 @@ void CoreSMTSolver::declareVarsToTheories() { // First empty the solver theory_handler.clear(); - for (int i = 0; i < var_seen.size(); i++) + for (int i = 0; i < var_seen.size(); i++) { var_seen[i] = false; + } - for (int i = 0; i < trail.size(); i++) - { + for (int i = 0; i < trail.size(); i++) { Var v = var(trail[i]); - if (!var_seen[v]) { - var_seen[v] = true; - const Logic & logic = theory_handler.getLogic(); - const PTRef term = theory_handler.varToTerm(v); - if (logic.isTheoryTerm(term)) { - theory_handler.declareAtom(term); - } + if (var_seen[v]) { continue; } + var_seen[v] = true; + const Logic & logic = theory_handler.getLogic(); + const PTRef term = theory_handler.varToTerm(v); + if (logic.isTheoryTerm(term)) { + theory_handler.declareAtom(term); } } + const Logic & logic = theory_handler.getLogic(); top_level_lits = trail.size(); for (int i = 0; i < clauses.size(); i++) { Clause & c = ca[clauses[i]]; for (unsigned j = 0; j < c.size(); j++) { Var v = var(c[j]); - if (!var_seen[v]) { - var_seen[v] = true; - assert(theory_handler.ptrefToVar(theory_handler.varToTerm(v)) == v); - const PTRef term = theory_handler.varToTerm(v); - if (logic.isTheoryTerm(term)) { - theory_handler.declareAtom(term); - } + if (var_seen[v]) { continue; } + var_seen[v] = true; + assert(theory_handler.ptrefToVar(theory_handler.varToTerm(v)) == v); + const PTRef term = theory_handler.varToTerm(v); + if (logic.isTheoryTerm(term)) { + theory_handler.declareAtom(term); } } } + for (Var v = 0; v < var_seen.size(); v++) { - if (not var_seen[v]) { - PTRef atom = theory_handler.varToTerm(v); - bool appearsInUf = logic.appearsInUF(atom); - if (appearsInUf) { - theory_handler.declareAtom(atom); - } else { - setDecisionVar(v, false); - } + if (var_seen[v]) { continue; } + PTRef atom = theory_handler.varToTerm(v); + bool appearsInUf = logic.appearsInUF(atom); + if (appearsInUf) { + theory_handler.declareAtom(atom); + } else { + setDecisionVar(v, false); } } } diff --git a/src/smtsolvers/CoreSMTSolver.h b/src/smtsolvers/CoreSMTSolver.h index 8e4961a45..f1be26025 100644 --- a/src/smtsolvers/CoreSMTSolver.h +++ b/src/smtsolvers/CoreSMTSolver.h @@ -170,6 +170,12 @@ class CoreSMTSolver inline bool isOK ( ) const { return ok; } // FALSE means solver is in a conflicting state inline int getConflictFrame ( ) const { assert(not isOK()); return conflict_frame; } + bool areUserBranchLitsEmpty() const { return userBranchLits.empty(); } + std::size_t userBranchLitsSize() const { return userBranchLits.size(); } + void pushUserBranchLit(Lit l) { userBranchLits.push_back(l); } + void popUserBranchLit() { userBranchLits.pop_back(); } + void clearUserBranchLits() { userBranchLits.clear(); } + template void printSMTClause (std::ostream &, const C& ); void printSMTClause (std::ostream &, vec< Lit > &, bool = false ); @@ -366,7 +372,7 @@ class CoreSMTSolver virtual lbool pickUserBranchSignFor(Var) { return l_Undef; } virtual bool pickBranchSignFor(Var); virtual Lit mkBranchLitFrom(Var); - virtual Lit pickUserBranchLit() { return lit_Undef; } + virtual Lit pickUserBranchLit(); virtual Lit pickBranchLit(); // Return the next decision variable. virtual void newDecisionLevel (); // Begins a new decision level. void uncheckedEnqueue (Lit p, CRef from = CRef_Undef); // Enqueue a literal. Assumes value of literal is undefined. @@ -484,6 +490,8 @@ class CoreSMTSolver vec lit_to_restore; // For cancelUntilVarTemp vec val_to_restore; // For cancelUntilVarTemp + std::vector userBranchLits; + // // ResolutionProof production // From 12e41fd84ba885cce52bb301a60c2483784fc82c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Thu, 30 Oct 2025 10:03:12 +0100 Subject: [PATCH 06/11] Unit tests for decision preferences of literals or asserted terms --- test/unit/CMakeLists.txt | 8 + test/unit/test_DecisionPreference.cc | 2352 ++++++++++++++++++++++++++ 2 files changed, 2360 insertions(+) create mode 100644 test/unit/test_DecisionPreference.cc diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt index 115d7b018..13f7b7fd4 100644 --- a/test/unit/CMakeLists.txt +++ b/test/unit/CMakeLists.txt @@ -259,3 +259,11 @@ target_sources(ScopedVectorTest target_link_libraries(ScopedVectorTest OpenSMT gtest gtest_main) gtest_add_tests(TARGET ScopedVectorTest) + +add_executable(DecisionPreferenceTest) +target_sources(DecisionPreferenceTest + PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/test_DecisionPreference.cc" + ) + +target_link_libraries(DecisionPreferenceTest OpenSMT gtest gtest_main) +gtest_add_tests(TARGET DecisionPreferenceTest) diff --git a/test/unit/test_DecisionPreference.cc b/test/unit/test_DecisionPreference.cc new file mode 100644 index 000000000..0f7c0ca1f --- /dev/null +++ b/test/unit/test_DecisionPreference.cc @@ -0,0 +1,2352 @@ +/* + * Copyright (c) 2025, Tomas Kolarik + * + * SPDX-License-Identifier: MIT + * + */ + +#include +#include + +namespace opensmt { + +class DecisionPreferenceTest : public ::testing::Test { +public: + void init(Logic_t logic_t = Logic_t::QF_BOOL) { + logic = std::make_unique(logic_t); + config = std::make_unique(); + config->setProduceModels(); + mainSolver = std::make_unique(*logic, *config, "test"); + + a = logic->mkBoolVar("a"); + b = logic->mkBoolVar("b"); + not_a = logic->mkNot(a); + not_b = logic->mkNot(b); + + and_ab = logic->mkAnd(a, b); + or_ab = logic->mkOr(a, b); + xor_ab = logic->mkXor(a, b); + eq_ab = logic->mkEq(a, b); + impl_ab = logic->mkImpl(a, b); + impl_ba = logic->mkImpl(b, a); + + and_nab = logic->mkAnd(not_a, b); + and_anb = logic->mkAnd(a, not_b); + and_nanb = logic->mkAnd(not_a, not_b); + or_nanb = logic->mkOr(not_a, not_b); + } + + void checkBool(sstat expRes, lbool expValA = l_Undef, lbool expValB = l_Undef) const { + auto res = mainSolver->check(); + EXPECT_EQ(res, expRes); + if (expRes != s_True) { return; } + + auto model = mainSolver->getModel(); + PTRef val_a = model->evaluate(a); + PTRef val_b = model->evaluate(b); + PTRef exp_val_a = lboolValToPTRef(expValA); + PTRef exp_val_b = lboolValToPTRef(expValB); + EXPECT_EQ(val_a, exp_val_a); + EXPECT_EQ(val_b, exp_val_b); + } + +protected: + PTRef lboolValToPTRef(lbool val) const { + if (val == l_False) { return logic->getTerm_false(); } + if (val == l_True) { return logic->getTerm_true(); } + return logic->getDefaultValuePTRef(logic->getSort_bool()); + } + + std::unique_ptr logic; + std::unique_ptr config; + std::unique_ptr mainSolver; + + PTRef a; + PTRef b; + PTRef not_a; + PTRef not_b; + + PTRef and_ab; + PTRef or_ab; + PTRef xor_ab; + PTRef eq_ab; + PTRef impl_ab; + PTRef impl_ba; + + PTRef and_nab; + PTRef and_anb; + PTRef and_nanb; + PTRef or_nanb; +}; + +TEST_F(DecisionPreferenceTest, test_Unconstrained__DecisionPreferenceA) { + init(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_Undef, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_Undef, l_False); +} + +TEST_F(DecisionPreferenceTest, test_Unconstrained__DecisionPreferenceNotA) { + init(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_Undef, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_Undef, l_False); +} + +TEST_F(DecisionPreferenceTest, test_A__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(a); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_A__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(a); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_NotA__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(not_a); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_NotA__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(not_a); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_AB__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(and_ab); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_False); +} + +TEST_F(DecisionPreferenceTest, test_AB__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(and_ab); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(or_ab); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(or_ab); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(xor_ab); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(xor_ab); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(eq_ab); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(eq_ab); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(impl_ab); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(impl_ab); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(impl_ba); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(impl_ba); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_NotAB__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(and_nab); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_False); +} + +TEST_F(DecisionPreferenceTest, test_NotAB__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(and_nab); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_False); +} + +TEST_F(DecisionPreferenceTest, test_NotB__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(and_anb); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_ANotB__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(and_anb); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_NotANotB__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(and_nanb); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_NotANotB__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(and_nanb); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceA) { + init(); + mainSolver->addAssertion(or_nanb); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceNotA) { + init(); + mainSolver->addAssertion(or_nanb); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +///////////////////////////////////////////////////////////////////////////// + +// Adding more complex preferences that are however present in the asserted formulas + +TEST_F(DecisionPreferenceTest, test_OrAndABOrAB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_ab, or_ab})); + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotABOrAB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nab, or_ab})); + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndANotBOrAB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_anb, or_ab})); + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotANotBOrAB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nanb, or_ab})); + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndABXorAB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_ab, xor_ab})); + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotABXorAB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nab, xor_ab})); + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndANotBXorAB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_anb, xor_ab})); + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotANotBXorAB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nanb, xor_ab})); + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndABEqAB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_ab, eq_ab})); + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotABEqAB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nab, eq_ab})); + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndANotBEqAB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_anb, eq_ab})); + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotANotBEqAB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nanb, eq_ab})); + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndABImplAB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_ab, impl_ab})); + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotABImplAB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nab, impl_ab})); + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndANotBImplAB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_anb, impl_ab})); + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotANotBImplAB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nanb, impl_ab})); + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndABImplBA__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_ab, impl_ba})); + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotABImplBA__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nab, impl_ba})); + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndANotBImplBA__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_anb, impl_ba})); + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotANotBImplBA__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nanb, impl_ba})); + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndABOrNotANotB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_ab, or_nanb})); + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotABOrNotANotB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nab, or_nanb})); + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndANotBOrNotANotB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_anb, or_nanb})); + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); +} + +TEST_F(DecisionPreferenceTest, test_OrAndNotANotBOrNotANotB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(logic->mkOr({and_nanb, or_nanb})); + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); +} + +} From 950b07f93a9f86a79e84fc08231b9c9cef729b6a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Thu, 30 Oct 2025 17:21:43 +0100 Subject: [PATCH 07/11] Added decision preferences of unseen terms --- src/api/MainSolver.cc | 59 +++++++++++++++++++++++++++++++++---------- src/api/MainSolver.h | 9 ++++++- 2 files changed, 53 insertions(+), 15 deletions(-) diff --git a/src/api/MainSolver.cc b/src/api/MainSolver.cc index f896b8201..ade4b88a3 100644 --- a/src/api/MainSolver.cc +++ b/src/api/MainSolver.cc @@ -185,7 +185,7 @@ sstat MainSolver::simplifyFormulas() { if (status == s_False) { break; } for (PTRef pref : decisionPreferences.scope(i)) { - giveDecisionPreferenceToSMTSolver(pref); + giveDecisionPreferenceToSMTSolver(pref, frameId); } } @@ -347,24 +347,56 @@ PTRef MainSolver::rewriteMaxArity(PTRef root) { return opensmt::rewriteMaxArityClassic(logic, root); } -void MainSolver::giveDecisionPreferenceToSMTSolver(PTRef pref) { +void MainSolver::giveDecisionPreferenceToSMTSolver(PTRef pref, FrameId frameId) { assert(logic.getSortRef(pref) == logic.getSort_bool()); assert(not logic.isConstant(pref)); - Lit l; - if (logic.isBoolVarLiteral(pref)) { - l = term_mapper->getOrCreateLit(pref); - Var v = var(l); - smt_solver->addVar(v); - } else { - // Ignores substitutions .. - assert(term_mapper->hasLit(pref)); - l = term_mapper->getLit(pref); - } + // Ignores substitutions .. + Lit l = [&] { + if (term_mapper->hasLit(pref)) { return giveExistingDecisionPreferenceToSMTSolver(pref); } + if (logic.isBoolVarLiteral(pref)) { return giveBoolVarDecisionPreferenceToSMTSolver(pref); } + return giveAnyDecisionPreferenceToSMTSolver(pref, frameId); + }(); + + decisionPreferenceToLitMap.emplace(pref, l); +} + +Lit MainSolver::giveExistingDecisionPreferenceToSMTSolver(PTRef pref) { + assert(term_mapper->hasLit(pref)); + + ++existingDecisionPreferencesGivenToSMTSolverCount; + return term_mapper->getLit(pref); +} + +Lit MainSolver::giveBoolVarDecisionPreferenceToSMTSolver(PTRef pref) { + assert(logic.isBoolVarLiteral(pref)); + + Lit l = term_mapper->getOrCreateLit(pref); + Var v = var(l); + smt_solver->addVar(v); assert(term_mapper->getLit(pref) == l); assert(term_mapper->getVar(pref) == var(l)); - decisionPreferenceToLitMap.emplace(pref, l); + ++boolVarDecisionPreferencesGivenToSMTSolverCount; + return l; +} + +Lit MainSolver::giveAnyDecisionPreferenceToSMTSolver(PTRef pref, FrameId frameId) { + assert(not term_mapper->hasLit(pref)); + assert(not logic.isBoolVarLiteral(pref)); + + auto name = std::string{".pref"} + std::to_string(pref.x); + PTRef decisionVarTerm = logic.mkBoolVar(name.c_str()); + Lit l = term_mapper->getOrCreateLit(decisionVarTerm); + PTRef condTerm = logic.mkImpl(decisionVarTerm, pref); + [[maybe_unused]] + sstat status = giveToSolver(condTerm, frameId); + assert(status == s_Undef); + assert(term_mapper->getLit(decisionVarTerm) == l); + assert(term_mapper->getVar(decisionVarTerm) == var(l)); + + ++otherDecisionPreferencesGivenToSMTSolverCount; + return l; } std::unique_ptr MainSolver::getModel() { @@ -419,7 +451,6 @@ std::unique_ptr MainSolver::getInterpolationContext() { } sstat MainSolver::giveToSolver(PTRef root, FrameId push_id) { - struct ClauseCallBack : public Cnfizer::ClauseCallBack { std::vector> clauses; void operator()(vec && c) override { clauses.push_back(std::move(c)); } diff --git a/src/api/MainSolver.h b/src/api/MainSolver.h index 022de4fef..90bb56418 100644 --- a/src/api/MainSolver.h +++ b/src/api/MainSolver.h @@ -308,7 +308,10 @@ class MainSolver { PTRef rewriteMaxArity(PTRef root); - void giveDecisionPreferenceToSMTSolver(PTRef); + void giveDecisionPreferenceToSMTSolver(PTRef, FrameId); + Lit giveExistingDecisionPreferenceToSMTSolver(PTRef); + Lit giveBoolVarDecisionPreferenceToSMTSolver(PTRef); + Lit giveAnyDecisionPreferenceToSMTSolver(PTRef, FrameId); virtual sstat solve_(vec const & enabledFrames); @@ -327,6 +330,10 @@ class MainSolver { sstat status = s_Undef; // The status of the last solver call + std::size_t existingDecisionPreferencesGivenToSMTSolverCount{}; + std::size_t boolVarDecisionPreferencesGivenToSMTSolverCount{}; + std::size_t otherDecisionPreferencesGivenToSMTSolverCount{}; + private: std::unique_ptr theory; std::unique_ptr term_mapper; From 059087c46e0a526869140ec40b5f98eab7e5f3f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Thu, 6 Nov 2025 11:24:40 +0100 Subject: [PATCH 08/11] Unit tests for decision preferences of unseen terms --- test/unit/test_DecisionPreference.cc | 2288 +++++++++++++++++++++++++- 1 file changed, 2281 insertions(+), 7 deletions(-) diff --git a/test/unit/test_DecisionPreference.cc b/test/unit/test_DecisionPreference.cc index 0f7c0ca1f..d1a10b6d4 100644 --- a/test/unit/test_DecisionPreference.cc +++ b/test/unit/test_DecisionPreference.cc @@ -5,18 +5,25 @@ * */ -#include #include +#include namespace opensmt { +class TestMainSolver : public MainSolver { +public: + using MainSolver::MainSolver; + + friend class DecisionPreferenceTest; +}; + class DecisionPreferenceTest : public ::testing::Test { public: void init(Logic_t logic_t = Logic_t::QF_BOOL) { logic = std::make_unique(logic_t); config = std::make_unique(); config->setProduceModels(); - mainSolver = std::make_unique(*logic, *config, "test"); + mainSolver = std::make_unique(*logic, *config, "test"); a = logic->mkBoolVar("a"); b = logic->mkBoolVar("b"); @@ -34,9 +41,23 @@ class DecisionPreferenceTest : public ::testing::Test { and_anb = logic->mkAnd(a, not_b); and_nanb = logic->mkAnd(not_a, not_b); or_nanb = logic->mkOr(not_a, not_b); + + existingTotalCount = 0; + boolVarTotalCount = 0; + otherTotalCount = 0; + } + + void checkPreferenceCount(std::size_t existingCount, std::size_t boolVarCount, std::size_t otherCount) const { + EXPECT_EQ(mainSolver->existingDecisionPreferencesGivenToSMTSolverCount, existingCount); + EXPECT_EQ(mainSolver->boolVarDecisionPreferencesGivenToSMTSolverCount, boolVarCount); + EXPECT_EQ(mainSolver->otherDecisionPreferencesGivenToSMTSolverCount, otherCount); + } + + void checkPreferenceIncCount(std::size_t existingIncCount, std::size_t boolVarIncCount, std::size_t otherIncCount) const { + checkPreferenceCount(existingTotalCount += existingIncCount, boolVarTotalCount += boolVarIncCount, otherTotalCount += otherIncCount); } - void checkBool(sstat expRes, lbool expValA = l_Undef, lbool expValB = l_Undef) const { + void checkBool(sstat expRes, lbool expValA = l_Undef, lbool expValB = l_Undef) { auto res = mainSolver->check(); EXPECT_EQ(res, expRes); if (expRes != s_True) { return; } @@ -44,22 +65,25 @@ class DecisionPreferenceTest : public ::testing::Test { auto model = mainSolver->getModel(); PTRef val_a = model->evaluate(a); PTRef val_b = model->evaluate(b); + assert(val_a != PTRef_Undef); + assert(val_b != PTRef_Undef); PTRef exp_val_a = lboolValToPTRef(expValA); PTRef exp_val_b = lboolValToPTRef(expValB); - EXPECT_EQ(val_a, exp_val_a); - EXPECT_EQ(val_b, exp_val_b); + if (exp_val_a != PTRef_Undef) { EXPECT_EQ(val_a, exp_val_a); } + if (exp_val_b != PTRef_Undef) { EXPECT_EQ(val_b, exp_val_b); } } protected: PTRef lboolValToPTRef(lbool val) const { if (val == l_False) { return logic->getTerm_false(); } if (val == l_True) { return logic->getTerm_true(); } - return logic->getDefaultValuePTRef(logic->getSort_bool()); + // return logic->getDefaultValuePTRef(logic->getSort_bool()); + return PTRef_Undef; } std::unique_ptr logic; std::unique_ptr config; - std::unique_ptr mainSolver; + std::unique_ptr mainSolver; PTRef a; PTRef b; @@ -77,6 +101,10 @@ class DecisionPreferenceTest : public ::testing::Test { PTRef and_anb; PTRef and_nanb; PTRef or_nanb; + + std::size_t mutable existingTotalCount; + std::size_t mutable boolVarTotalCount; + std::size_t mutable otherTotalCount; }; TEST_F(DecisionPreferenceTest, test_Unconstrained__DecisionPreferenceA) { @@ -85,27 +113,32 @@ TEST_F(DecisionPreferenceTest, test_Unconstrained__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True); + checkPreferenceIncCount(1, 1, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True); + checkPreferenceIncCount(1, 1, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_Undef, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_Undef, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_Unconstrained__DecisionPreferenceNotA) { @@ -114,27 +147,32 @@ TEST_F(DecisionPreferenceTest, test_Unconstrained__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True); + checkPreferenceIncCount(1, 1, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True); + checkPreferenceIncCount(1, 1, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_Undef, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_Undef, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_A__DecisionPreferenceA) { @@ -144,27 +182,32 @@ TEST_F(DecisionPreferenceTest, test_A__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True); + checkPreferenceIncCount(1, 1, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_A__DecisionPreferenceNotA) { @@ -174,27 +217,32 @@ TEST_F(DecisionPreferenceTest, test_A__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True); + checkPreferenceIncCount(1, 1, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_NotA__DecisionPreferenceA) { @@ -204,27 +252,32 @@ TEST_F(DecisionPreferenceTest, test_NotA__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False); + checkPreferenceIncCount(1, 1, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_NotA__DecisionPreferenceNotA) { @@ -234,27 +287,32 @@ TEST_F(DecisionPreferenceTest, test_NotA__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False); + checkPreferenceIncCount(1, 1, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_AB__DecisionPreferenceA) { @@ -264,27 +322,32 @@ TEST_F(DecisionPreferenceTest, test_AB__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_AB__DecisionPreferenceNotA) { @@ -294,27 +357,32 @@ TEST_F(DecisionPreferenceTest, test_AB__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceA) { @@ -324,27 +392,32 @@ TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceNotA) { @@ -354,27 +427,32 @@ TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceA) { @@ -384,27 +462,32 @@ TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceNotA) { @@ -414,27 +497,32 @@ TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceA) { @@ -444,27 +532,32 @@ TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceNotA) { @@ -474,27 +567,32 @@ TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceA) { @@ -504,27 +602,32 @@ TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceNotA) { @@ -534,27 +637,32 @@ TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceA) { @@ -564,27 +672,32 @@ TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceNotA) { @@ -594,27 +707,32 @@ TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_NotAB__DecisionPreferenceA) { @@ -624,27 +742,32 @@ TEST_F(DecisionPreferenceTest, test_NotAB__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_NotAB__DecisionPreferenceNotA) { @@ -654,27 +777,32 @@ TEST_F(DecisionPreferenceTest, test_NotAB__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_NotB__DecisionPreferenceA) { @@ -684,27 +812,32 @@ TEST_F(DecisionPreferenceTest, test_NotB__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_ANotB__DecisionPreferenceNotA) { @@ -714,27 +847,32 @@ TEST_F(DecisionPreferenceTest, test_ANotB__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_NotANotB__DecisionPreferenceA) { @@ -744,27 +882,32 @@ TEST_F(DecisionPreferenceTest, test_NotANotB__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_NotANotB__DecisionPreferenceNotA) { @@ -774,27 +917,32 @@ TEST_F(DecisionPreferenceTest, test_NotANotB__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceA) { @@ -804,27 +952,32 @@ TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceA) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceNotA) { @@ -834,27 +987,32 @@ TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceNotA) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } ///////////////////////////////////////////////////////////////////////////// @@ -871,27 +1029,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABOrAB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -900,27 +1063,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABOrAB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotABOrAB__DecisionPreferenceNotAB) { @@ -933,27 +1101,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABOrAB__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -962,27 +1135,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABOrAB__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndANotBOrAB__DecisionPreferenceANotB) { @@ -995,27 +1173,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBOrAB__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1024,27 +1207,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBOrAB__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotANotBOrAB__DecisionPreferenceNotANotB) { @@ -1057,27 +1245,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBOrAB__DecisionPreferenceNotANot mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1086,27 +1279,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBOrAB__DecisionPreferenceNotANot mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndABXorAB__DecisionPreferenceAB) { @@ -1119,27 +1317,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABXorAB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1148,27 +1351,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABXorAB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotABXorAB__DecisionPreferenceNotAB) { @@ -1181,27 +1389,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABXorAB__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1210,27 +1423,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABXorAB__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndANotBXorAB__DecisionPreferenceANotB) { @@ -1243,27 +1461,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBXorAB__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1272,27 +1495,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBXorAB__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotANotBXorAB__DecisionPreferenceNotANotB) { @@ -1305,27 +1533,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBXorAB__DecisionPreferenceNotANo mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1334,27 +1567,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBXorAB__DecisionPreferenceNotANo mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndABEqAB__DecisionPreferenceAB) { @@ -1367,27 +1605,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABEqAB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1396,27 +1639,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABEqAB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotABEqAB__DecisionPreferenceNotAB) { @@ -1429,27 +1677,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABEqAB__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1458,27 +1711,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABEqAB__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndANotBEqAB__DecisionPreferenceANotB) { @@ -1491,27 +1749,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBEqAB__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1520,27 +1783,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBEqAB__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotANotBEqAB__DecisionPreferenceNotANotB) { @@ -1553,27 +1821,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBEqAB__DecisionPreferenceNotANot mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1582,27 +1855,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBEqAB__DecisionPreferenceNotANot mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndABImplAB__DecisionPreferenceAB) { @@ -1615,27 +1893,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABImplAB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1644,27 +1927,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABImplAB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotABImplAB__DecisionPreferenceNotAB) { @@ -1677,27 +1965,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABImplAB__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1706,27 +1999,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABImplAB__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndANotBImplAB__DecisionPreferenceANotB) { @@ -1739,27 +2037,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBImplAB__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1768,27 +2071,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBImplAB__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotANotBImplAB__DecisionPreferenceNotANotB) { @@ -1801,27 +2109,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBImplAB__DecisionPreferenceNotAN mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1830,27 +2143,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBImplAB__DecisionPreferenceNotAN mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndABImplBA__DecisionPreferenceAB) { @@ -1863,27 +2181,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABImplBA__DecisionPreferenceAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1892,27 +2215,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABImplBA__DecisionPreferenceAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotABImplBA__DecisionPreferenceNotAB) { @@ -1925,27 +2253,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABImplBA__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -1954,27 +2287,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABImplBA__DecisionPreferenceNotAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndANotBImplBA__DecisionPreferenceANotB) { @@ -1987,27 +2325,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBImplBA__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -2016,27 +2359,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBImplBA__DecisionPreferenceANotB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotANotBImplBA__DecisionPreferenceNotANotB) { @@ -2049,27 +2397,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBImplBA__DecisionPreferenceNotAN mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -2078,27 +2431,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBImplBA__DecisionPreferenceNotAN mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndABOrNotANotB__DecisionPreferenceAB) { @@ -2111,27 +2469,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABOrNotANotB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -2140,27 +2503,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndABOrNotANotB__DecisionPreferenceAB) { mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotABOrNotANotB__DecisionPreferenceNotAB) { @@ -2173,27 +2541,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABOrNotANotB__DecisionPreferenceNotA mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -2202,27 +2575,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotABOrNotANotB__DecisionPreferenceNotA mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndANotBOrNotANotB__DecisionPreferenceANotB) { @@ -2235,27 +2613,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBOrNotANotB__DecisionPreferenceANot mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -2264,27 +2647,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndANotBOrNotANotB__DecisionPreferenceANot mainSolver->addDecisionPreference(a); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } TEST_F(DecisionPreferenceTest, test_OrAndNotANotBOrNotANotB__DecisionPreferenceNotANotB) { @@ -2297,27 +2685,32 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBOrNotANotB__DecisionPreferenceN mainSolver->addDecisionPreference(not_a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(3, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->pop(); @@ -2326,27 +2719,1908 @@ TEST_F(DecisionPreferenceTest, test_OrAndNotANotBOrNotANotB__DecisionPreferenceN mainSolver->addDecisionPreference(a); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->push(); mainSolver->addDecisionPreference(b); mainSolver->addDecisionPreference(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addDecisionPreference(not_b); mainSolver->addDecisionPreference(b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(b); checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); mainSolver->pop(); mainSolver->push(); mainSolver->addAssertion(not_b); checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +///////////////////////////////////////////////////////////////////////////// + +// Adding more complex preferences that are *not* present in the asserted formulas + +TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(or_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_ab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(or_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } +TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(or_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_anb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); } + +TEST_F(DecisionPreferenceTest, test_OrAB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(or_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nanb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(xor_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_ab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(xor_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(xor_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_anb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_XorAB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(xor_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nanb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(eq_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_ab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(eq_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(eq_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_anb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_EqAB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(eq_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nanb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(impl_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_ab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(impl_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(impl_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_anb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_ImplAB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(impl_ab); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nanb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(impl_ba); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_ab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(impl_ba); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(impl_ba); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_anb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_ImplBA__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(impl_ba); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nanb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_True, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceAB) { + init(); + mainSolver->addAssertion(or_nanb); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_ab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_ab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceNotAB) { + init(); + mainSolver->addAssertion(or_nanb); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nab); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nab); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceANotB) { + init(); + mainSolver->addAssertion(or_nanb); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_anb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_anb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_True, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceNotANotB) { + init(); + mainSolver->addAssertion(or_nanb); + + // Also check that it does not use already invalid assertions + mainSolver->push(); + mainSolver->addAssertion(and_nanb); + mainSolver->pop(); + + mainSolver->addDecisionPreference(and_nanb); + + mainSolver->push(); + mainSolver->addDecisionPreference(a); + mainSolver->addDecisionPreference(not_a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 1); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_a); + mainSolver->addDecisionPreference(a); + + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->push(); + mainSolver->addDecisionPreference(b); + mainSolver->addDecisionPreference(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(not_b); + mainSolver->addDecisionPreference(b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(2, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(b); + checkBool(s_True, l_False, l_True); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(not_b); + checkBool(s_True, l_False, l_False); + checkPreferenceIncCount(0, 0, 0); +} + +} // namespace opensmt From 066f7498af589d6c520a4d0f755743e2f050ebe2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Tue, 11 Nov 2025 18:05:43 +0100 Subject: [PATCH 09/11] Basic unit tests for arithmetic decision preferences --- test/unit/test_DecisionPreference.cc | 375 ++++++++++++++++++++++++++- 1 file changed, 371 insertions(+), 4 deletions(-) diff --git a/test/unit/test_DecisionPreference.cc b/test/unit/test_DecisionPreference.cc index d1a10b6d4..3c7a5fb10 100644 --- a/test/unit/test_DecisionPreference.cc +++ b/test/unit/test_DecisionPreference.cc @@ -14,13 +14,15 @@ class TestMainSolver : public MainSolver { public: using MainSolver::MainSolver; - friend class DecisionPreferenceTest; + template + friend class DecisionPreferenceTestTp; }; -class DecisionPreferenceTest : public ::testing::Test { +template +class DecisionPreferenceTestTp : public ::testing::Test { public: void init(Logic_t logic_t = Logic_t::QF_BOOL) { - logic = std::make_unique(logic_t); + logic = std::make_unique(logic_t); config = std::make_unique(); config->setProduceModels(); mainSolver = std::make_unique(*logic, *config, "test"); @@ -81,7 +83,7 @@ class DecisionPreferenceTest : public ::testing::Test { return PTRef_Undef; } - std::unique_ptr logic; + std::unique_ptr logic; std::unique_ptr config; std::unique_ptr mainSolver; @@ -107,6 +109,8 @@ class DecisionPreferenceTest : public ::testing::Test { std::size_t mutable otherTotalCount; }; +using DecisionPreferenceTest = DecisionPreferenceTestTp<>; + TEST_F(DecisionPreferenceTest, test_Unconstrained__DecisionPreferenceA) { init(); mainSolver->addDecisionPreference(a); @@ -4623,4 +4627,367 @@ TEST_F(DecisionPreferenceTest, test_OrNotANotB__DecisionPreferenceNotANotB) { checkPreferenceIncCount(0, 0, 0); } +///////////////////////////////////////////////////////////////////////////// +///////////////////////////////////////////////////////////////////////////// + +constexpr int int_Undef = -1; + +class IntDecisionPreferenceTest : public DecisionPreferenceTestTp { +public: + void init(Logic_t logic_t = Logic_t::QF_LIA) { + DecisionPreferenceTestTp::init(logic_t); + + x = logic->mkIntVar("x"); + y = logic->mkIntVar("y"); + + eq0_x = logic->mkEq(x, logic->mkIntConst(0)); + eq0_y = logic->mkEq(y, logic->mkIntConst(0)); + eq1_x = logic->mkEq(x, logic->mkIntConst(1)); + eq1_y = logic->mkEq(y, logic->mkIntConst(1)); + eq2_x = logic->mkEq(x, logic->mkIntConst(2)); + eq2_y = logic->mkEq(y, logic->mkIntConst(2)); + } + + void checkInt(sstat expRes, int expValX = int_Undef, int expValY = int_Undef) { + auto res = mainSolver->check(); + EXPECT_EQ(res, expRes); + if (expRes != s_True) { return; } + + auto model = mainSolver->getModel(); + PTRef val_x = model->evaluate(x); + PTRef val_y = model->evaluate(y); + assert(val_x != PTRef_Undef); + assert(val_y != PTRef_Undef); + PTRef exp_val_x = intValToPTRef(expValX); + PTRef exp_val_y = intValToPTRef(expValY); + if (exp_val_x != PTRef_Undef) { EXPECT_EQ(val_x, exp_val_x); } + if (exp_val_y != PTRef_Undef) { EXPECT_EQ(val_y, exp_val_y); } + } + +protected: + PTRef intValToPTRef(int val) const { + if (val == 0) { return logic->getTerm_IntZero(); } + if (val == 1) { return logic->getTerm_IntOne(); } + if (val > 1) { return logic->mkIntConst(val); } + assert(val < 0); + static_assert(int_Undef < 0); + // return logic->getDefaultValuePTRef(logic->getSort_int()); + return PTRef_Undef; + } + + PTRef x; + PTRef y; + + PTRef eq0_x; + PTRef eq0_y; + PTRef eq1_x; + PTRef eq1_y; + PTRef eq2_x; + PTRef eq2_y; +}; + +// Atomic preferences + +TEST_F(IntDecisionPreferenceTest, test_OrXOrY__DecisionPreferenceXY) { + init(); + mainSolver->addAssertion(logic->mkOr({eq0_x, eq1_x, eq2_x})); + mainSolver->addAssertion(logic->mkOr({eq0_y, eq1_y, eq2_y})); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + + checkInt(s_True, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 0); +} + +// More complex, asserted preferences + +TEST_F(IntDecisionPreferenceTest, test_OrAndXY__DecisionPreferenceXY) { + init(); + mainSolver->addAssertion(logic->mkOr({ + logic->mkAnd(eq0_x, eq0_y), logic->mkAnd(eq0_x, eq1_y), logic->mkAnd(eq0_x, eq2_y), + logic->mkAnd(eq1_x, eq0_y), logic->mkAnd(eq1_x, eq1_y), logic->mkAnd(eq1_x, eq2_y), + logic->mkAnd(eq2_x, eq0_y), logic->mkAnd(eq2_x, eq1_y), logic->mkAnd(eq2_x, eq2_y), + })); + + mainSolver->push(); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq2_y)); + + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 9); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq2_y)); + + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 9); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq2_y)); + + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 9); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq2_y)); + + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 9); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq2_y)); + + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 9); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq2_y)); + + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 9); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq2_y)); + + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 9); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq2_y)); + + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 9); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq2_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq1_x, eq0_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq2_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq1_y)); + mainSolver->addDecisionPreference(logic->mkAnd(eq0_x, eq0_y)); + + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 9); +} + } // namespace opensmt From 27c2b2f369c14ec93e9f8f1aaa285e7168818f6d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Tue, 11 Nov 2025 18:10:33 +0100 Subject: [PATCH 10/11] Preprocessing decision preferences --- src/api/MainSolver.cc | 20 +++++++++++++++----- src/api/MainSolver.h | 4 ++-- 2 files changed, 17 insertions(+), 7 deletions(-) diff --git a/src/api/MainSolver.cc b/src/api/MainSolver.cc index ade4b88a3..1e7ac4b54 100644 --- a/src/api/MainSolver.cc +++ b/src/api/MainSolver.cc @@ -185,7 +185,7 @@ sstat MainSolver::simplifyFormulas() { if (status == s_False) { break; } for (PTRef pref : decisionPreferences.scope(i)) { - giveDecisionPreferenceToSMTSolver(pref, frameId); + giveDecisionPreferenceToSMTSolver(pref, frameId, context); } } @@ -347,7 +347,7 @@ PTRef MainSolver::rewriteMaxArity(PTRef root) { return opensmt::rewriteMaxArityClassic(logic, root); } -void MainSolver::giveDecisionPreferenceToSMTSolver(PTRef pref, FrameId frameId) { +void MainSolver::giveDecisionPreferenceToSMTSolver(PTRef pref, FrameId frameId, PreprocessingContext const & pcontext) { assert(logic.getSortRef(pref) == logic.getSort_bool()); assert(not logic.isConstant(pref)); @@ -355,7 +355,7 @@ void MainSolver::giveDecisionPreferenceToSMTSolver(PTRef pref, FrameId frameId) Lit l = [&] { if (term_mapper->hasLit(pref)) { return giveExistingDecisionPreferenceToSMTSolver(pref); } if (logic.isBoolVarLiteral(pref)) { return giveBoolVarDecisionPreferenceToSMTSolver(pref); } - return giveAnyDecisionPreferenceToSMTSolver(pref, frameId); + return giveAnyDecisionPreferenceToSMTSolver(pref, frameId, pcontext); }(); decisionPreferenceToLitMap.emplace(pref, l); @@ -381,17 +381,27 @@ Lit MainSolver::giveBoolVarDecisionPreferenceToSMTSolver(PTRef pref) { return l; } -Lit MainSolver::giveAnyDecisionPreferenceToSMTSolver(PTRef pref, FrameId frameId) { +Lit MainSolver::giveAnyDecisionPreferenceToSMTSolver(PTRef pref, FrameId frameId, + PreprocessingContext const & pcontext) { assert(not term_mapper->hasLit(pref)); assert(not logic.isBoolVarLiteral(pref)); + // Cannot preprocess pref unconditionally - may result in a conflict + auto name = std::string{".pref"} + std::to_string(pref.x); PTRef decisionVarTerm = logic.mkBoolVar(name.c_str()); Lit l = term_mapper->getOrCreateLit(decisionVarTerm); PTRef condTerm = logic.mkImpl(decisionVarTerm, pref); + + assert(not pcontext.perPartition); + PTRef processed = preprocessFormula(condTerm, pcontext); + assert(not logic.isConstant(processed)); + assert(not logic.isBoolVarLiteral(processed)); + [[maybe_unused]] - sstat status = giveToSolver(condTerm, frameId); + sstat status = giveToSolver(processed, frameId); assert(status == s_Undef); + assert(term_mapper->getLit(decisionVarTerm) == l); assert(term_mapper->getVar(decisionVarTerm) == var(l)); diff --git a/src/api/MainSolver.h b/src/api/MainSolver.h index 90bb56418..854c4cc64 100644 --- a/src/api/MainSolver.h +++ b/src/api/MainSolver.h @@ -308,10 +308,10 @@ class MainSolver { PTRef rewriteMaxArity(PTRef root); - void giveDecisionPreferenceToSMTSolver(PTRef, FrameId); + void giveDecisionPreferenceToSMTSolver(PTRef, FrameId, PreprocessingContext const &); Lit giveExistingDecisionPreferenceToSMTSolver(PTRef); Lit giveBoolVarDecisionPreferenceToSMTSolver(PTRef); - Lit giveAnyDecisionPreferenceToSMTSolver(PTRef, FrameId); + Lit giveAnyDecisionPreferenceToSMTSolver(PTRef, FrameId, PreprocessingContext const &); virtual sstat solve_(vec const & enabledFrames); From e9ab79421f18186a96e22f6f4ac3606fc1a3aac3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kol=C3=A1rik?= Date: Tue, 11 Nov 2025 18:53:22 +0100 Subject: [PATCH 11/11] Unit tests for arithmetic decision preferences --- test/unit/test_DecisionPreference.cc | 1139 +++++++++++++++++++++++++- 1 file changed, 1138 insertions(+), 1 deletion(-) diff --git a/test/unit/test_DecisionPreference.cc b/test/unit/test_DecisionPreference.cc index 3c7a5fb10..af0cc13ee 100644 --- a/test/unit/test_DecisionPreference.cc +++ b/test/unit/test_DecisionPreference.cc @@ -4640,12 +4640,27 @@ class IntDecisionPreferenceTest : public DecisionPreferenceTestTp { x = logic->mkIntVar("x"); y = logic->mkIntVar("y"); + geq0_x = logic->mkGeq(x, logic->mkIntConst(0)); + geq0_y = logic->mkGeq(y, logic->mkIntConst(0)); + geq1_x = logic->mkGeq(x, logic->mkIntConst(1)); + geq1_y = logic->mkGeq(y, logic->mkIntConst(1)); + leq1_x = logic->mkLeq(x, logic->mkIntConst(1)); + leq1_y = logic->mkLeq(y, logic->mkIntConst(1)); + leq2_x = logic->mkLeq(x, logic->mkIntConst(2)); + leq2_y = logic->mkLeq(y, logic->mkIntConst(2)); eq0_x = logic->mkEq(x, logic->mkIntConst(0)); eq0_y = logic->mkEq(y, logic->mkIntConst(0)); eq1_x = logic->mkEq(x, logic->mkIntConst(1)); eq1_y = logic->mkEq(y, logic->mkIntConst(1)); eq2_x = logic->mkEq(x, logic->mkIntConst(2)); eq2_y = logic->mkEq(y, logic->mkIntConst(2)); + + geq_xy = logic->mkGeq(x, y); + leq_xy = logic->mkLeq(x, y); + eq_xy = logic->mkEq(x, y); + gt_xy = logic->mkGt(x, y); + lt_xy = logic->mkLt(x, y); + neq_xy = logic->mkNot(eq_xy); } void checkInt(sstat expRes, int expValX = int_Undef, int expValY = int_Undef) { @@ -4678,15 +4693,30 @@ class IntDecisionPreferenceTest : public DecisionPreferenceTestTp { PTRef x; PTRef y; + PTRef geq0_x; + PTRef geq0_y; + PTRef geq1_x; + PTRef geq1_y; + PTRef leq1_x; + PTRef leq1_y; + PTRef leq2_x; + PTRef leq2_y; PTRef eq0_x; PTRef eq0_y; PTRef eq1_x; PTRef eq1_y; PTRef eq2_x; PTRef eq2_y; + + PTRef geq_xy; + PTRef leq_xy; + PTRef eq_xy; + PTRef gt_xy; + PTRef lt_xy; + PTRef neq_xy; }; -// Atomic preferences +// Atomic, asserted preferences TEST_F(IntDecisionPreferenceTest, test_OrXOrY__DecisionPreferenceXY) { init(); @@ -4845,6 +4875,1113 @@ TEST_F(IntDecisionPreferenceTest, test_OrXOrY__DecisionPreferenceXY) { checkPreferenceIncCount(0, 0, 0); } +// Atomic, unseen preferences + +TEST_F(IntDecisionPreferenceTest, test_IntervalXIntervalY__DecisionPreferenceXY) { + init(); + mainSolver->addAssertion(logic->mkAnd({geq0_x, leq2_x})); + mainSolver->addAssertion(logic->mkAnd({geq0_y, leq2_y})); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + + checkInt(s_True, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(IntDecisionPreferenceTest, test_IntervalXIntervalYGeqXY__DecisionPreferenceXY) { + init(); + mainSolver->addAssertion(logic->mkAnd({geq0_x, leq2_x})); + mainSolver->addAssertion(logic->mkAnd({geq0_y, leq2_y})); + mainSolver->addAssertion(geq_xy); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + + checkInt(s_True, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(IntDecisionPreferenceTest, test_IntervalXIntervalYLeqXY__DecisionPreferenceXY) { + init(); + mainSolver->addAssertion(logic->mkAnd({geq0_x, leq2_x})); + mainSolver->addAssertion(logic->mkAnd({geq0_y, leq2_y})); + mainSolver->addAssertion(leq_xy); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(IntDecisionPreferenceTest, test_IntervalXIntervalYEqXY__DecisionPreferenceXY) { + init(); + mainSolver->addAssertion(logic->mkAnd({geq0_x, leq2_x})); + mainSolver->addAssertion(logic->mkAnd({geq0_y, leq2_y})); + mainSolver->addAssertion(eq_xy); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 0, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 1, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 2, 2); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(IntDecisionPreferenceTest, test_IntervalXIntervalYGtXY__DecisionPreferenceXY) { + init(); + mainSolver->addAssertion(logic->mkAnd({geq0_x, leq2_x})); + mainSolver->addAssertion(logic->mkAnd({geq0_y, leq2_y})); + mainSolver->addAssertion(gt_xy); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + + checkInt(s_True, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_False); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(IntDecisionPreferenceTest, test_IntervalXIntervalYLtXY__DecisionPreferenceXY) { + init(); + mainSolver->addAssertion(logic->mkAnd({geq0_x, leq2_x})); + mainSolver->addAssertion(logic->mkAnd({geq0_y, leq2_y})); + mainSolver->addAssertion(lt_xy); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_False); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 0); +} + +TEST_F(IntDecisionPreferenceTest, test_IntervalXIntervalYNeqXY__DecisionPreferenceXY) { + init(); + mainSolver->addAssertion(logic->mkAnd({geq0_x, leq2_x})); + mainSolver->addAssertion(logic->mkAnd({geq0_y, leq2_y})); + mainSolver->addAssertion(neq_xy); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 0, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + mainSolver->addDecisionPreference(eq2_x); + + checkInt(s_True, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 1, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 0, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_x); + mainSolver->addDecisionPreference(eq1_x); + mainSolver->addDecisionPreference(eq0_x); + + checkInt(s_True, 2); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->push(); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + mainSolver->addDecisionPreference(eq2_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addDecisionPreference(eq2_y); + mainSolver->addDecisionPreference(eq1_y); + mainSolver->addDecisionPreference(eq0_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 3); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq0_y); + checkInt(s_True, 2, 0); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq1_y); + checkInt(s_True, 2, 1); + checkPreferenceIncCount(0, 0, 0); + + mainSolver->pop(); + mainSolver->push(); + mainSolver->addAssertion(eq2_y); + checkInt(s_True, 1, 2); + checkPreferenceIncCount(0, 0, 0); +} + // More complex, asserted preferences TEST_F(IntDecisionPreferenceTest, test_OrAndXY__DecisionPreferenceXY) {