TEST(normal_interface, logfile2_assumps)
{
SATSolver* s = new SATSolver();
s->log_to_file("testfile");
s->new_vars(2);
s->add_clause(vector<Lit>{Lit(0, false)});
s->add_clause(vector<Lit>{Lit(0, false), Lit(1, false)});
std::vector<Lit> assumps {Lit(0, false), Lit(1, true)};
lbool ret = s->solve(&assumps);
s->add_clause(vector<Lit>{Lit(1, false)});
assumps.clear();
assumps.push_back(Lit(1, true));
ret = s->solve(&assumps);
delete s;
std::ifstream infile("testfile");
std::string line;
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::new_vars( 2 )");
std::getline(infile, line);
EXPECT_EQ(line, "1 0");
std::getline(infile, line);
EXPECT_EQ(line, "1 2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( 1 -2 )");
std::getline(infile, line);
EXPECT_EQ(line, "2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( -2 )");
}
TEST(normal_interface, logfile2)
{
SATSolver* s = new SATSolver();
s->log_to_file("testfile");
s->new_vars(2);
s->add_clause(vector<Lit>{Lit(0, false)});
s->add_clause(vector<Lit>{Lit(0, false), Lit(1, false)});
lbool ret = s->solve();
s->add_clause(vector<Lit>{Lit(1, false)});
ret = s->solve();
delete s;
std::ifstream infile("testfile");
std::string line;
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::new_vars( 2 )");
std::getline(infile, line);
EXPECT_EQ(line, "1 0");
std::getline(infile, line);
EXPECT_EQ(line, "1 2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( )");
std::getline(infile, line);
EXPECT_EQ(line, "2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( )");
}
TEST(error_throw, multithread_newvar)
{
SATSolver s;
s.new_vars(3);
EXPECT_THROW({
s.set_num_threads(3);}
, std::runtime_error);
TEST(xor_interface, xor_check_unsat)
{
SATSolver s;
s.new_vars(3);
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, false);
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, true);
lbool ret = s.solve();
EXPECT_EQ( ret, l_False);
EXPECT_EQ( s.nVars(), 3u);
}
TEST(stp_test, set_num_threads_true)
{
SATSolver s;
s.set_num_threads(5);
s.new_vars(2);
s.add_clause(str_to_cl("1,2"));
s.add_clause(str_to_cl("1,-2"));
lbool ret = s.solve();
EXPECT_EQ(ret, l_True);
EXPECT_EQ(s.get_model()[0], l_True);
}
TEST(xor_interface, unit)
{
SATSolver s;
s.new_vars(3);
s.add_clause(vector<Lit>{Lit(0, false)});
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
vector<Lit> units = s.get_zero_assigned_lits();
EXPECT_EQ( units.size(), 1u);
EXPECT_EQ( units[0], Lit(0, false));
}
TEST(normal_interface, max_time)
{
SATSolver* s = new SATSolver();
s->new_vars(200);
s->add_clause(str_to_cl("1"));
s->add_clause(str_to_cl("1, 2"));
s->set_max_time(3);
lbool ret = s->solve();
s->add_clause(vector<Lit>{Lit(1, false)});
ret = s->solve();
delete s;
EXPECT_EQ(ret, l_True);
}
TEST(stp_test, default_polar_false)
{
SATSolver s;
s.set_no_simplify_at_startup();
s.set_default_polarity(false);
s.new_vars(4);
s.add_clause(str_to_cl("-1, -2, -3, -4"));
lbool ret = s.solve();
EXPECT_EQ(ret, l_True);
for(size_t i = 0; i < 4; i++) {
EXPECT_EQ(s.get_model()[0], l_False);
}
}
TEST(stp_test, set_num_threads_false)
{
SATSolver s;
s.set_no_simplify_at_startup();
s.set_num_threads(5);
s.new_vars(2);
s.add_clause(str_to_cl("1,2"));
s.add_clause(str_to_cl("1,-2"));
s.add_clause(str_to_cl("-1,2"));
s.add_clause(str_to_cl("-1,-2"));
lbool ret = s.solve();
EXPECT_EQ(ret, l_False);
}
TEST(xor_interface, xor_norm_mix_unsat_multi_thread)
{
SATSolver s;
//s.set_num_threads(3);
s.new_vars(3);
s.add_clause(vector<Lit>{Lit(0, false)});
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, false);
s.add_clause(vector<Lit>{Lit(1, false)});
s.add_clause(vector<Lit>{Lit(2, false)});
lbool ret = s.solve();
EXPECT_EQ( ret, l_False);
EXPECT_EQ( s.nVars(), 3u);
}
int main(int argc, const char* argv[]) {
if (argc < 2) {
std::cout << "Run: incremental-cryptominisat <varNumber> <timeLimit in seconds>" << std::endl;
return 1;
}
int var_number = atoi(argv[1]);
int time_limit = atoi(argv[2]);
SolverConf conf;
conf.maxTime = time_limit;
SATSolver solver (conf, NULL);
solver.new_vars(var_number);
while (true) {
std::string line;
std::getline(std::cin, line);
if (line == "solve") {
lbool res = solver.solve();
if (res == l_True) {
std::cout << "SAT" << std::endl;
std::vector<lbool> model = solver.get_model();
std::cout << "v ";
for (int i = 0; i < model.size(); i++) {
std::cout << (model[i] == l_True ? "" : "-") << (i + 1) << " ";
}
std::cout << std::endl;
} else if (res == l_False) {
std::cout << "UNSAT" << std::endl;
} else {
std::cout << "UNKNOWN" << std::endl;
}
} else if (line == "halt") {
break;
} else {
std::vector<Lit> lits;
std::istringstream iss(line);
do {
std::string sub;
iss >> sub;
int literal = atoi(sub.c_str());
if (literal == 0) {
break;
}
lits.push_back(Lit(abs(literal) - 1, literal < 0));
} while (iss);
solver.add_clause(lits);
}
}
return 0;
}
TEST(xor_interface, unit3)
{
SATSolver s;
s.new_vars(3);
s.add_clause(str_to_cl("1"));
s.add_clause(str_to_cl("-1, -2"));
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
vector<Lit> units = s.get_zero_assigned_lits();
EXPECT_EQ( units.size(), 2u);
EXPECT_EQ( units[0], Lit(0, false));
EXPECT_EQ( units[1], Lit(1, true));
}
TEST(normal_interface, solve_multi_thread)
{
SATSolver s;
s.set_num_threads(2);
s.new_vars(2);
s.add_clause(str_to_cl("1, 2"));
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
s.add_clause(str_to_cl("-1"));
ret = s.solve();
EXPECT_EQ( ret, l_True);
EXPECT_EQ(s.get_model()[0], l_False);
EXPECT_EQ(s.get_model()[1], l_True);
}
TEST(normal_interface, solve_multi_thread)
{
SATSolver s;
s.set_num_threads(2);
s.new_vars(2);
s.add_clause(vector<Lit>{Lit(0, false), Lit(1, false)});
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
s.add_clause(vector<Lit>{Lit(0, true)});
ret = s.solve();
EXPECT_EQ( ret, l_True);
EXPECT_EQ(s.get_model()[0], l_False);
EXPECT_EQ(s.get_model()[1], l_True);
}
void add_clauses_for_simp_check(SATSolver& s)
{
s.new_vars(4);
// 1 = 2
s.add_clause(str_to_cl("1, -2"));
s.add_clause(str_to_cl("-1, 2"));
// 3 = 4
s.add_clause(str_to_cl("3, -4"));
s.add_clause(str_to_cl("-3, 4"));
//no elimination
s.add_clause(str_to_cl("3, 2"));
s.add_clause(str_to_cl("4, 1"));
}
TEST(xor_interface, abort_early)
{
SATSolver s;
s.set_no_simplify();
s.set_no_equivalent_lit_replacement();
s.set_num_threads(2);
s.set_max_confl(0);
s.new_vars(2);
s.add_clause(str_to_cl("1, 2"));
s.add_clause(str_to_cl("1, -2"));
s.add_clause(str_to_cl("-1, 2"));
s.add_clause(str_to_cl("-1, -2"));
lbool ret = s.solve();
EXPECT_EQ( ret, l_Undef);
}
TEST(xor_interface, abort_early)
{
SATSolver s;
s.set_no_simplify();
s.set_no_equivalent_lit_replacement();
s.set_num_threads(2);
s.set_max_confl(0);
s.new_vars(2);
s.add_clause(vector<Lit>{Lit(0, false), Lit(1, false)});
s.add_clause(vector<Lit>{Lit(0, false), Lit(1, true)});
s.add_clause(vector<Lit>{Lit(0, true), Lit(1, false)});
s.add_clause(vector<Lit>{Lit(0, true), Lit(1, true)});
lbool ret = s.solve();
EXPECT_EQ( ret, l_Undef);
}
TEST(normal_interface, logfile)
{
SATSolver* s = new SATSolver();
s->log_to_file("testfile");
s->new_vars(2);
s->add_clause(str_to_cl("1, 2"));
lbool ret = s->solve();
EXPECT_EQ( ret, l_True);
delete s;
std::ifstream infile("testfile");
std::string line;
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::new_vars( 2 )");
std::getline(infile, line);
EXPECT_EQ(line, "1 2 0");
std::getline(infile, line);
EXPECT_EQ(line, "c Solver::solve( )");
}
TEST(xor_interface, xor_check_unsat_multi_solve_multi_thread)
{
SATSolver s;
s.set_num_threads(3);
s.new_vars(3);
s.add_xor_clause(vector<uint32_t>{0U, 1U}, false);
s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, true);
lbool ret = s.solve();
EXPECT_EQ( ret, l_True);
EXPECT_EQ( s.nVars(), 3u);
s.add_xor_clause(vector<uint32_t>{0U}, false);
ret = s.solve();
EXPECT_EQ( ret, l_True);
EXPECT_EQ( s.get_model()[0], l_False);
EXPECT_EQ( s.get_model()[1], l_False);
EXPECT_EQ( s.get_model()[2], l_True);
EXPECT_EQ( s.nVars(), 3u);
s.add_xor_clause(vector<uint32_t>{1U}, true);
ret = s.solve();
EXPECT_EQ( ret, l_False);
EXPECT_EQ( s.nVars(), 3u);
}
