Jip J. Dekker
981be2067e
git-subtree-dir: software/gecode_on_replay git-subtree-split: 8051d92b9c89e49cccfbd1c201371580d7703ab4
1152 lines
37 KiB
C++
Executable File
1152 lines
37 KiB
C++
Executable File
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
|
|
/*
|
|
* Main authors:
|
|
* Christian Schulte <schulte@gecode.org>
|
|
* Mikael Lagerkvist <lagerkvist@gecode.org>
|
|
*
|
|
* Copyright:
|
|
* Christian Schulte, 2005
|
|
* Mikael Lagerkvist, 2005
|
|
*
|
|
* This file is part of Gecode, the generic constraint
|
|
* development environment:
|
|
* http://www.gecode.org
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
* a copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be
|
|
* included in all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
*/
|
|
|
|
#include "test/int.hh"
|
|
|
|
#include <algorithm>
|
|
|
|
namespace Test { namespace Int {
|
|
|
|
|
|
/*
|
|
* Complete assignments
|
|
*
|
|
*/
|
|
void
|
|
CpltAssignment::next(Gecode::Support::RandomGenerator&) {
|
|
int i = n-1;
|
|
while (true) {
|
|
++dsv[i];
|
|
if (dsv[i]() || (i == 0))
|
|
return;
|
|
dsv[i--].init(d);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Random assignments
|
|
*
|
|
*/
|
|
void RandomAssignment::next(Gecode::Support::RandomGenerator& rand) {
|
|
for (int i = this->n; i--; )
|
|
this->vals[i]= this->randval(rand);
|
|
this->a--;
|
|
}
|
|
|
|
void
|
|
RandomMixAssignment::next(Gecode::Support::RandomGenerator& rand) {
|
|
for (int i=n-_n1; i--; )
|
|
vals[i] = randval(d, rand);
|
|
for (int i=_n1; i--; )
|
|
vals[n-_n1+i] = randval(_d1, rand);
|
|
a--;
|
|
}
|
|
|
|
}}
|
|
|
|
std::ostream&
|
|
operator<<(std::ostream& os, const Test::Int::Assignment& a) {
|
|
int n = a.size();
|
|
os << "{";
|
|
for (int i=0; i<n; i++)
|
|
os << a[i] << ((i!=n-1) ? "," : "}");
|
|
return os;
|
|
}
|
|
|
|
namespace Test { namespace Int {
|
|
|
|
TestSpace::TestSpace(int n, Gecode::IntSet& d0, Test* t)
|
|
: d(d0), x(*this,n,Gecode::Int::Limits::min,Gecode::Int::Limits::max),
|
|
test(t), reified(false) {
|
|
Gecode::IntVarArgs _x(*this,n,d);
|
|
if (x.size() == 1)
|
|
Gecode::dom(*this,x[0],_x[0]);
|
|
else
|
|
Gecode::dom(*this,x,_x);
|
|
Gecode::BoolVar b(*this,0,1);
|
|
r = Gecode::Reify(b,Gecode::RM_EQV);
|
|
if (opt.log)
|
|
olog << ind(2) << "Initial: x[]=" << x
|
|
<< std::endl;
|
|
}
|
|
|
|
TestSpace::TestSpace(int n, Gecode::IntSet& d0, Test* t,
|
|
Gecode::ReifyMode rm)
|
|
: d(d0), x(*this,n,Gecode::Int::Limits::min,Gecode::Int::Limits::max),
|
|
test(t), reified(true) {
|
|
Gecode::IntVarArgs _x(*this,n,d);
|
|
if (x.size() == 1)
|
|
Gecode::dom(*this,x[0],_x[0]);
|
|
else
|
|
Gecode::dom(*this,x,_x);
|
|
Gecode::BoolVar b(*this,0,1);
|
|
r = Gecode::Reify(b,rm);
|
|
if (opt.log)
|
|
olog << ind(2) << "Initial: x[]=" << x
|
|
<< " b=" << r.var() << std::endl;
|
|
}
|
|
|
|
TestSpace::TestSpace(TestSpace& s)
|
|
: Gecode::Space(s), d(s.d), test(s.test), reified(s.reified) {
|
|
x.update(*this, s.x);
|
|
Gecode::BoolVar b;
|
|
Gecode::BoolVar sr(s.r.var());
|
|
b.update(*this, sr);
|
|
r.var(b); r.mode(s.r.mode());
|
|
}
|
|
|
|
Gecode::Space*
|
|
TestSpace::copy(void) {
|
|
return new TestSpace(*this);
|
|
}
|
|
|
|
bool
|
|
TestSpace::assigned(void) const {
|
|
for (int i=x.size(); i--; )
|
|
if (!x[i].assigned())
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
void
|
|
TestSpace::post(void) {
|
|
if (reified){
|
|
test->post(*this,x,r);
|
|
if (opt.log)
|
|
olog << ind(3) << "Posting reified propagator" << std::endl;
|
|
} else {
|
|
test->post(*this,x);
|
|
if (opt.log)
|
|
olog << ind(3) << "Posting propagator" << std::endl;
|
|
}
|
|
}
|
|
|
|
bool
|
|
TestSpace::failed(void) {
|
|
if (opt.log) {
|
|
olog << ind(3) << "Fixpoint: " << x;
|
|
bool f=(status() == Gecode::SS_FAILED);
|
|
olog << std::endl << ind(3) << " --> " << x << std::endl;
|
|
return f;
|
|
} else {
|
|
return status() == Gecode::SS_FAILED;
|
|
}
|
|
}
|
|
|
|
int
|
|
TestSpace::rndvar(Gecode::Support::RandomGenerator& rand) {
|
|
assert(!assigned());
|
|
// Select variable to be pruned
|
|
int i = static_cast<int>(rand(static_cast<unsigned int>(x.size())));
|
|
while (x[i].assigned()) {
|
|
i = (i+1) % x.size();
|
|
}
|
|
return i;
|
|
}
|
|
|
|
void
|
|
TestSpace::rndrel(const Assignment& a, int i, Gecode::IntRelType& irt, int& v,
|
|
Gecode::Support::RandomGenerator& rand) {
|
|
using namespace Gecode;
|
|
// Select mode for pruning
|
|
irt = IRT_EQ; // Means do nothing!
|
|
switch (rand(3)) {
|
|
case 0:
|
|
if (a[i] < x[i].max()) {
|
|
v=a[i]+1+
|
|
static_cast<int>(rand(static_cast<unsigned int>(x[i].max()-a[i])));
|
|
assert((v > a[i]) && (v <= x[i].max()));
|
|
irt = IRT_LE;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (a[i] > x[i].min()) {
|
|
v=x[i].min()+
|
|
static_cast<int>(rand(static_cast<unsigned int>(a[i]-x[i].min())));
|
|
assert((v < a[i]) && (v >= x[i].min()));
|
|
irt = IRT_GR;
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
Gecode::Int::ViewRanges<Gecode::Int::IntView> it(x[i]);
|
|
unsigned int skip = rand(static_cast<unsigned int>(x[i].size()-1));
|
|
while (true) {
|
|
if (it.width() > skip) {
|
|
v = it.min() + static_cast<int>(skip);
|
|
if (v == a[i]) {
|
|
if (it.width() == 1) {
|
|
++it; v = it.min();
|
|
} else if (v < it.max()) {
|
|
++v;
|
|
} else {
|
|
--v;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
skip -= it.width(); ++it;
|
|
}
|
|
irt = IRT_NQ;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
TestSpace::rel(int i, Gecode::IntRelType irt, int n) {
|
|
if (opt.log) {
|
|
olog << ind(4) << "x[" << i << "] ";
|
|
switch (irt) {
|
|
case Gecode::IRT_EQ: olog << "="; break;
|
|
case Gecode::IRT_NQ: olog << "!="; break;
|
|
case Gecode::IRT_LQ: olog << "<="; break;
|
|
case Gecode::IRT_LE: olog << "<"; break;
|
|
case Gecode::IRT_GQ: olog << ">="; break;
|
|
case Gecode::IRT_GR: olog << ">"; break;
|
|
}
|
|
olog << " " << n << std::endl;
|
|
}
|
|
Gecode::rel(*this, x[i], irt, n);
|
|
}
|
|
|
|
void
|
|
TestSpace::rel(bool sol) {
|
|
int n = sol ? 1 : 0;
|
|
assert(reified);
|
|
if (opt.log)
|
|
olog << ind(4) << "b = " << n << std::endl;
|
|
Gecode::rel(*this, r.var(), Gecode::IRT_EQ, n);
|
|
}
|
|
|
|
void
|
|
TestSpace::assign(const Assignment& a, bool skip, Gecode::Support::RandomGenerator& rand) {
|
|
using namespace Gecode;
|
|
int i = skip ?
|
|
static_cast<int>(rand(static_cast<unsigned int>(a.size()))) : -1;
|
|
for (int j=a.size(); j--; )
|
|
if (i != j) {
|
|
rel(j, IRT_EQ, a[j]);
|
|
if (Base::fixpoint(rand) && failed())
|
|
return;
|
|
}
|
|
}
|
|
|
|
void
|
|
TestSpace::bound(Gecode::Support::RandomGenerator& rand) {
|
|
using namespace Gecode;
|
|
int i = rndvar(rand);
|
|
bool min = rand(2);
|
|
rel(i, IRT_EQ, min ? x[i].min() : x[i].max());
|
|
}
|
|
|
|
void
|
|
TestSpace::prune(int i, bool bounds_only, Gecode::Support::RandomGenerator& rand) {
|
|
using namespace Gecode;
|
|
// Prune values
|
|
if (bounds_only) {
|
|
if (rand(2) && !x[i].assigned()) {
|
|
int v=x[i].min()+1+
|
|
static_cast<int>(rand(static_cast<unsigned int>(x[i].max()-x[i].min())));
|
|
assert((v > x[i].min()) && (v <= x[i].max()));
|
|
rel(i, Gecode::IRT_LE, v);
|
|
}
|
|
if (rand(2) && !x[i].assigned()) {
|
|
int v=x[i].min()+
|
|
static_cast<int>(rand(static_cast<unsigned int>(x[i].max()-x[i].min())));
|
|
assert((v < x[i].max()) && (v >= x[i].min()));
|
|
rel(i, Gecode::IRT_GR, v);
|
|
}
|
|
} else {
|
|
for (int vals =
|
|
static_cast<int>(rand(static_cast<unsigned int>(x[i].size()-1))+1); vals--; ) {
|
|
int v;
|
|
Gecode::Int::ViewRanges<Gecode::Int::IntView> it(x[i]);
|
|
unsigned int skip = rand(x[i].size()-1);
|
|
while (true) {
|
|
if (it.width() > skip) {
|
|
v = it.min() + static_cast<int>(skip); break;
|
|
}
|
|
skip -= it.width(); ++it;
|
|
}
|
|
rel(i, IRT_NQ, v);
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
TestSpace::prune(Gecode::Support::RandomGenerator& rand) {
|
|
prune(rndvar(rand), false, rand);
|
|
}
|
|
|
|
bool
|
|
TestSpace::prune(const Assignment& a, bool testfix, Gecode::Support::RandomGenerator& rand) {
|
|
using namespace Gecode;
|
|
// Select variable to be pruned
|
|
int i = rndvar(rand);
|
|
// Select mode for pruning
|
|
IntRelType irt;
|
|
int v;
|
|
rndrel(a, i, irt, v, rand);
|
|
if (irt != IRT_EQ)
|
|
rel(i, irt, v);
|
|
if (Base::fixpoint(rand)) {
|
|
if (failed() || !testfix)
|
|
return true;
|
|
TestSpace* c = static_cast<TestSpace*>(clone());
|
|
if (opt.log)
|
|
olog << ind(3) << "Testing fixpoint on copy" << std::endl;
|
|
c->post();
|
|
if (c->failed()) {
|
|
if (opt.log)
|
|
olog << ind(4) << "Copy failed after posting" << std::endl;
|
|
delete c; return false;
|
|
}
|
|
for (int j=x.size(); j--; )
|
|
if (x[j].size() != c->x[j].size()) {
|
|
if (opt.log)
|
|
olog << ind(4) << "Different domain size" << std::endl;
|
|
delete c; return false;
|
|
}
|
|
if (reified && (r.var().size() != c->r.var().size())) {
|
|
if (opt.log)
|
|
olog << ind(4) << "Different control variable" << std::endl;
|
|
delete c; return false;
|
|
}
|
|
if (opt.log)
|
|
olog << ind(3) << "Finished testing fixpoint on copy" << std::endl;
|
|
delete c;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void
|
|
TestSpace::enable(void) {
|
|
Gecode::PropagatorGroup::all.enable(*this);
|
|
}
|
|
|
|
void
|
|
TestSpace::disable(void) {
|
|
Gecode::PropagatorGroup::all.disable(*this);
|
|
(void) status();
|
|
}
|
|
|
|
bool
|
|
TestSpace::disabled(const Assignment& a, TestSpace& c, bool testfix, Gecode::Support::RandomGenerator& rand) {
|
|
using namespace Gecode;
|
|
// Disable propagators
|
|
c.disable();
|
|
// Select variable to be pruned
|
|
int i = rndvar(rand);
|
|
// Select mode for pruning
|
|
IntRelType irt;
|
|
int v;
|
|
rndrel(a, i, irt, v, rand);
|
|
if (irt != IRT_EQ) {
|
|
rel(i, irt, v);
|
|
c.rel(i, irt, v);
|
|
}
|
|
// Enable propagators
|
|
c.enable();
|
|
if (!testfix)
|
|
return true;
|
|
if (failed()) {
|
|
if (!c.failed()) {
|
|
if (opt.log)
|
|
olog << ind(3) << "No failure on disabled copy" << std::endl;
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
if (c.failed()) {
|
|
if (opt.log)
|
|
olog << ind(3) << "Failure on disabled copy" << std::endl;
|
|
return false;
|
|
}
|
|
for (int j=x.size(); j--; ) {
|
|
if (x[j].size() != c.x[j].size()) {
|
|
if (opt.log)
|
|
olog << ind(4) << "Different domain size" << std::endl;
|
|
return false;
|
|
}
|
|
if (reified && (r.var().size() != c.r.var().size())) {
|
|
if (opt.log)
|
|
olog << ind(4) << "Different control variable" << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
unsigned int
|
|
TestSpace::propagators(void) {
|
|
return Gecode::PropagatorGroup::all.size(*this);
|
|
}
|
|
|
|
const Gecode::IntPropLevel IntPropLevels::ipls[] =
|
|
{Gecode::IPL_DOM,Gecode::IPL_BND,Gecode::IPL_VAL};
|
|
|
|
const Gecode::IntPropLevel IntPropBasicAdvanced::ipls[] =
|
|
{Gecode::IPL_BASIC_ADVANCED,Gecode::IPL_ADVANCED,Gecode::IPL_BASIC};
|
|
|
|
const Gecode::IntRelType IntRelTypes::irts[] =
|
|
{Gecode::IRT_EQ,Gecode::IRT_NQ,Gecode::IRT_LQ,
|
|
Gecode::IRT_LE,Gecode::IRT_GQ,Gecode::IRT_GR};
|
|
|
|
const Gecode::BoolOpType BoolOpTypes::bots[] =
|
|
{Gecode::BOT_AND,Gecode::BOT_OR,Gecode::BOT_IMP,
|
|
Gecode::BOT_EQV,Gecode::BOT_XOR};
|
|
|
|
Assignment*
|
|
Test::assignment(void) const {
|
|
return new CpltAssignment(arity,dom);
|
|
}
|
|
|
|
|
|
/// Check the test result and handle failed test
|
|
#define CHECK_TEST(T,M) \
|
|
do { \
|
|
if (opt.log) \
|
|
olog << ind(3) << "Check: " << (M) << std::endl; \
|
|
if (!(T)) { \
|
|
problem = (M); delete s; goto failed; \
|
|
} \
|
|
} while (false)
|
|
|
|
/// Start new test
|
|
#define START_TEST(T) \
|
|
do { \
|
|
if (opt.log) { \
|
|
olog.str(""); \
|
|
olog << ind(2) << "Testing: " << (T) << std::endl; \
|
|
} \
|
|
test = (T); \
|
|
} while (false)
|
|
|
|
bool
|
|
Test::ignore(const Assignment&) const {
|
|
return false;
|
|
}
|
|
|
|
void
|
|
Test::post(Gecode::Space&, Gecode::IntVarArray&,
|
|
Gecode::Reify) {}
|
|
|
|
bool
|
|
Test::run(void) {
|
|
using namespace Gecode;
|
|
const char* test = "NONE";
|
|
const char* problem = "NONE";
|
|
|
|
// Set up assignments
|
|
Assignment* ap = assignment();
|
|
Assignment& a = *ap;
|
|
|
|
// Set up space for all solution search
|
|
TestSpace* search_s = new TestSpace(arity,dom,this);
|
|
post(*search_s,search_s->x);
|
|
branch(*search_s,search_s->x,INT_VAR_NONE(),INT_VAL_MIN());
|
|
Search::Options search_o;
|
|
search_o.threads = 1;
|
|
DFS<TestSpace> e_s(search_s,search_o);
|
|
delete search_s;
|
|
|
|
while (a.has_more()) {
|
|
bool sol = solution(a);
|
|
if (opt.log) {
|
|
olog << ind(1) << "Assignment: " << a
|
|
<< (sol ? " (solution)" : " (no solution)")
|
|
<< std::endl;
|
|
}
|
|
|
|
START_TEST("Assignment (after posting)");
|
|
{
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
TestSpace* sc = nullptr;
|
|
s->post();
|
|
switch (_rand(2)) {
|
|
case 0:
|
|
if (opt.log)
|
|
olog << ind(3) << "No copy" << std::endl;
|
|
sc = s;
|
|
s = nullptr;
|
|
break;
|
|
case 1:
|
|
if (opt.log)
|
|
olog << ind(3) << "Copy" << std::endl;
|
|
if (s->status() != SS_FAILED) {
|
|
sc = static_cast<TestSpace*>(s->clone());
|
|
} else {
|
|
sc = s; s = nullptr;
|
|
}
|
|
break;
|
|
default: assert(false);
|
|
}
|
|
sc->assign(a, false, _rand);
|
|
if (sol) {
|
|
CHECK_TEST(!sc->failed(), "Failed on solution");
|
|
CHECK_TEST(sc->propagators()==0, "No subsumption");
|
|
} else {
|
|
CHECK_TEST(sc->failed(), "Solved on non-solution");
|
|
}
|
|
delete s; delete sc;
|
|
}
|
|
START_TEST("Partial assignment (after posting)");
|
|
{
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
s->post();
|
|
s->assign(a, true, _rand);
|
|
(void) s->failed();
|
|
s->assign(a, false, _rand);
|
|
if (sol) {
|
|
CHECK_TEST(!s->failed(), "Failed on solution");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
} else {
|
|
CHECK_TEST(s->failed(), "Solved on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
START_TEST("Assignment (after posting, disable)");
|
|
{
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
s->post();
|
|
s->disable();
|
|
s->assign(a, false, _rand);
|
|
s->enable();
|
|
if (sol) {
|
|
CHECK_TEST(!s->failed(), "Failed on solution");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
} else {
|
|
CHECK_TEST(s->failed(), "Solved on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
START_TEST("Partial assignment (after posting, disable)");
|
|
{
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
s->post();
|
|
s->assign(a, true, _rand);
|
|
s->disable();
|
|
(void) s->failed();
|
|
s->assign(a, false, _rand);
|
|
s->enable();
|
|
if (sol) {
|
|
CHECK_TEST(!s->failed(), "Failed on solution");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
} else {
|
|
CHECK_TEST(s->failed(), "Solved on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
START_TEST("Assignment (before posting)");
|
|
{
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
s->assign(a, false, _rand);
|
|
s->post();
|
|
if (sol) {
|
|
CHECK_TEST(!s->failed(), "Failed on solution");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
} else {
|
|
CHECK_TEST(s->failed(), "Solved on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
START_TEST("Partial assignment (before posting)");
|
|
{
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
s->assign(a, true, _rand);
|
|
s->post();
|
|
(void) s->failed();
|
|
s->assign(a, false, _rand);
|
|
if (sol) {
|
|
CHECK_TEST(!s->failed(), "Failed on solution");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
} else {
|
|
CHECK_TEST(s->failed(), "Solved on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
START_TEST("Prune");
|
|
{
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
s->post();
|
|
while (!s->failed() && !s->assigned())
|
|
if (!s->prune(a, testfix, _rand)) {
|
|
problem = "No fixpoint";
|
|
delete s;
|
|
goto failed;
|
|
}
|
|
s->assign(a, false, _rand);
|
|
if (sol) {
|
|
CHECK_TEST(!s->failed(), "Failed on solution");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
} else {
|
|
CHECK_TEST(s->failed(), "Solved on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
START_TEST("Prune (disable)");
|
|
{
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
TestSpace* c = static_cast<TestSpace*>(s->clone());
|
|
s->post(); c->post();
|
|
while (!s->failed() && !s->assigned())
|
|
if (!s->disabled(a, *c, testfix, _rand)) {
|
|
problem = "Different result after re-enable";
|
|
delete s; delete c;
|
|
goto failed;
|
|
}
|
|
if (testfix && (s->failed() != c->failed())) {
|
|
problem = "Different failure after re-enable";
|
|
delete s; delete c;
|
|
goto failed;
|
|
}
|
|
delete s; delete c;
|
|
}
|
|
if (!ignore(a)) {
|
|
if (eqv()) {
|
|
{
|
|
START_TEST("Assignment reified (rewrite after post, <=>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_EQV);
|
|
s->post();
|
|
s->rel(sol);
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (rewrite failure, <=>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_EQV);
|
|
s->post();
|
|
s->rel(!sol);
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(s->failed(), "Not failed");
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (immediate rewrite, <=>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_EQV);
|
|
s->rel(sol);
|
|
s->post();
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (immediate failure, <=>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_EQV);
|
|
s->rel(!sol);
|
|
s->post();
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(s->failed(), "Not failed");
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (before posting, <=>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_EQV);
|
|
s->assign(a, false, _rand);
|
|
s->post();
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
if (sol) {
|
|
CHECK_TEST(s->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(s->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (after posting, <=>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_EQV);
|
|
s->post();
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
if (sol) {
|
|
CHECK_TEST(s->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(s->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (after posting, <=>, disable)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_EQV);
|
|
s->post();
|
|
s->disable();
|
|
s->assign(a, false, _rand);
|
|
s->enable();
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
if (sol) {
|
|
CHECK_TEST(s->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(s->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Prune reified, <=>");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_EQV);
|
|
s->post();
|
|
while (!s->failed() &&
|
|
(!s->assigned() || !s->r.var().assigned()))
|
|
if (!s->prune(a, testfix, _rand)) {
|
|
problem = "No fixpoint";
|
|
delete s;
|
|
goto failed;
|
|
}
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
if (sol) {
|
|
CHECK_TEST(s->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(s->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Prune reified, <=>, disable");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_EQV);
|
|
TestSpace* c = static_cast<TestSpace*>(s->clone());
|
|
s->post(); c->post();
|
|
while (!s->failed() &&
|
|
(!s->assigned() || !s->r.var().assigned()))
|
|
if (!s->disabled(a, *c, testfix, _rand)) {
|
|
problem = "No fixpoint";
|
|
delete s;
|
|
delete c;
|
|
goto failed;
|
|
}
|
|
CHECK_TEST(!c->failed(), "Failed");
|
|
CHECK_TEST(c->propagators()==0, "No subsumption");
|
|
CHECK_TEST(c->r.var().assigned(), "Control variable unassigned");
|
|
if (sol) {
|
|
CHECK_TEST(c->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(c->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
delete c;
|
|
}
|
|
}
|
|
|
|
if (imp()) {
|
|
{
|
|
START_TEST("Assignment reified (rewrite after post, =>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_IMP);
|
|
s->post();
|
|
s->rel(sol);
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (rewrite failure, =>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_IMP);
|
|
s->post();
|
|
s->rel(!sol);
|
|
s->assign(a, false, _rand);
|
|
if (sol) {
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
} else {
|
|
CHECK_TEST(s->failed(), "Not failed");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (immediate rewrite, =>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_IMP);
|
|
s->rel(sol);
|
|
s->post();
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (immediate failure, =>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_IMP);
|
|
s->rel(!sol);
|
|
s->post();
|
|
s->assign(a, false, _rand);
|
|
if (sol) {
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
} else {
|
|
CHECK_TEST(s->failed(), "Not failed");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (before posting, =>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_IMP);
|
|
s->assign(a, false, _rand);
|
|
s->post();
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
|
|
} else {
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(s->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (after posting, =>)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_IMP);
|
|
s->post();
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
|
|
} else {
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(s->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (after posting, =>, disable)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_IMP);
|
|
s->post();
|
|
s->disable();
|
|
s->assign(a, false, _rand);
|
|
s->enable();
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
|
|
} else {
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(s->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Prune reified, =>");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_IMP);
|
|
s->post();
|
|
while (!s->failed() &&
|
|
(!s->assigned() || (!sol && !s->r.var().assigned())))
|
|
if (!s->prune(a, testfix, _rand)) {
|
|
problem = "No fixpoint";
|
|
delete s;
|
|
goto failed;
|
|
}
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
|
|
} else {
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(s->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Prune reified, =>, disable");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_IMP);
|
|
TestSpace* c = static_cast<TestSpace*>(s->clone());
|
|
s->post(); c->post();
|
|
while (!s->failed() &&
|
|
(!s->assigned() || (!sol && !s->r.var().assigned())))
|
|
if (!s->disabled(a, *c, testfix, _rand)) {
|
|
problem = "No fixpoint";
|
|
delete s;
|
|
delete c;
|
|
goto failed;
|
|
}
|
|
CHECK_TEST(!c->failed(), "Failed");
|
|
CHECK_TEST(c->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(!c->r.var().assigned(), "Control variable assigned");
|
|
} else {
|
|
CHECK_TEST(c->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(c->r.var().val()==0, "One on non-solution");
|
|
}
|
|
delete s;
|
|
delete c;
|
|
}
|
|
}
|
|
|
|
if (pmi()) {
|
|
{
|
|
START_TEST("Assignment reified (rewrite after post, <=)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_PMI);
|
|
s->post();
|
|
s->rel(sol);
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (rewrite failure, <=)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_PMI);
|
|
s->post();
|
|
s->rel(!sol);
|
|
s->assign(a, false, _rand);
|
|
if (sol) {
|
|
CHECK_TEST(s->failed(), "Not failed");
|
|
} else {
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (immediate rewrite, <=)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_PMI);
|
|
s->rel(sol);
|
|
s->post();
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (immediate failure, <=)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_PMI);
|
|
s->rel(!sol);
|
|
s->post();
|
|
s->assign(a, false, _rand);
|
|
if (sol) {
|
|
CHECK_TEST(s->failed(), "Not failed");
|
|
} else {
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (before posting, <=)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_PMI);
|
|
s->assign(a, false, _rand);
|
|
s->post();
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(s->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (after posting, <=)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_PMI);
|
|
s->post();
|
|
s->assign(a, false, _rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(s->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Assignment reified (after posting, <=, disable)");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_PMI);
|
|
s->post();
|
|
s->disable();
|
|
s->assign(a, false, _rand);
|
|
s->enable();
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(s->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Prune reified, <=");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_PMI);
|
|
s->post();
|
|
while (!s->failed() &&
|
|
(!s->assigned() || (sol && !s->r.var().assigned())))
|
|
if (!s->prune(a, testfix, _rand)) {
|
|
problem = "No fixpoint";
|
|
delete s;
|
|
goto failed;
|
|
}
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(s->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(s->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(!s->r.var().assigned(), "Control variable assigned");
|
|
}
|
|
delete s;
|
|
}
|
|
{
|
|
START_TEST("Prune reified, <=, disable");
|
|
TestSpace* s = new TestSpace(arity,dom,this,RM_PMI);
|
|
TestSpace* c = static_cast<TestSpace*>(s->clone());
|
|
s->post(); c->post();
|
|
while (!s->failed() &&
|
|
(!s->assigned() || (sol && !s->r.var().assigned())))
|
|
if (!s->disabled(a, *c, testfix, _rand)) {
|
|
problem = "No fixpoint";
|
|
delete s;
|
|
delete c;
|
|
goto failed;
|
|
}
|
|
CHECK_TEST(!c->failed(), "Failed");
|
|
CHECK_TEST(c->propagators()==0, "No subsumption");
|
|
if (sol) {
|
|
CHECK_TEST(c->r.var().assigned(), "Control variable unassigned");
|
|
CHECK_TEST(c->r.var().val()==1, "Zero on solution");
|
|
} else {
|
|
CHECK_TEST(!c->r.var().assigned(), "Control variable assigned");
|
|
}
|
|
delete s;
|
|
delete c;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (testsearch) {
|
|
if (sol) {
|
|
START_TEST("Search");
|
|
TestSpace* s = e_s.next();
|
|
CHECK_TEST(s != nullptr, "Solutions exhausted");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
for (int i=a.size(); i--; ) {
|
|
CHECK_TEST(s->x[i].assigned(), "Unassigned variable");
|
|
CHECK_TEST(a[i] == s->x[i].val(), "Wrong value in solution");
|
|
}
|
|
delete s;
|
|
}
|
|
}
|
|
|
|
a.next(_rand);
|
|
}
|
|
|
|
if (testsearch) {
|
|
test = "Search";
|
|
if (e_s.next() != nullptr) {
|
|
problem = "Excess solutions";
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
switch (contest) {
|
|
case CTL_NONE: break;
|
|
case CTL_DOMAIN: {
|
|
START_TEST("Full domain consistency");
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
s->post();
|
|
if (!s->failed()) {
|
|
while (!s->failed() && !s->assigned())
|
|
s->prune(_rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
}
|
|
delete s;
|
|
// Fall-through -- domain implies bounds(d) and bounds(z)
|
|
}
|
|
case CTL_BOUNDS_D: {
|
|
START_TEST("Bounds(D)-consistency");
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
s->post();
|
|
for (int i = s->x.size(); i--; )
|
|
s->prune(i, false, _rand);
|
|
if (!s->failed()) {
|
|
while (!s->failed() && !s->assigned())
|
|
s->bound(_rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
}
|
|
delete s;
|
|
// Fall-through -- bounds(d) implies bounds(z)
|
|
}
|
|
case CTL_BOUNDS_Z: {
|
|
START_TEST("Bounds(Z)-consistency");
|
|
TestSpace* s = new TestSpace(arity,dom,this);
|
|
s->post();
|
|
for (int i = s->x.size(); i--; )
|
|
s->prune(i, true, _rand);
|
|
if (!s->failed()) {
|
|
while (!s->failed() && !s->assigned())
|
|
s->bound(_rand);
|
|
CHECK_TEST(!s->failed(), "Failed");
|
|
CHECK_TEST(s->propagators()==0, "No subsumption");
|
|
}
|
|
delete s;
|
|
break;
|
|
}
|
|
}
|
|
|
|
delete ap;
|
|
return true;
|
|
|
|
failed:
|
|
if (opt.log)
|
|
olog << "FAILURE" << std::endl
|
|
<< ind(1) << "Test: " << test << std::endl
|
|
<< ind(1) << "Problem: " << problem << std::endl;
|
|
if (a.has_more() && opt.log)
|
|
olog << ind(1) << "Assignment: " << a << std::endl;
|
|
delete ap;
|
|
|
|
return false;
|
|
}
|
|
|
|
}}
|
|
|
|
#undef START_TEST
|
|
#undef CHECK_TEST
|
|
|
|
// STATISTICS: test-int
|