def test_basic_types(self): self.assertTrue(BOOL.is_bool_type()) self.assertFalse(BOOL.is_function_type()) self.assertTrue(REAL.is_real_type()) self.assertFalse(REAL.is_bool_type()) self.assertTrue(INT.is_int_type()) self.assertFalse(INT.is_real_type()) ftype = FunctionType(REAL, [REAL, REAL]) self.assertTrue(ftype.is_function_type()) self.assertFalse(ftype.is_int_type()) self.assertNotEqual(BOOL, INT) self.assertEqual(REAL, REAL) AAIBR = ArrayType(ArrayType(INT, BOOL), REAL) self.assertEqual(str(AAIBR), "Array{Array{Int, Bool}, Real}") bt1 = BVType(4) bt2 = BVType(4) self.assertEqual(bt1, bt2) self.assertEqual(bt1.width, 4)
class TestFormulaManager(TestCase): def setUp(self): super(TestFormulaManager, self).setUp() self.env = get_env() self.mgr = self.env.formula_manager self.x = self.mgr.Symbol("x") self.y = self.mgr.Symbol("y") self.p = self.mgr.Symbol("p", INT) self.q = self.mgr.Symbol("q", INT) self.r = self.mgr.Symbol("r", REAL) self.s = self.mgr.Symbol("s", REAL) self.rconst = self.mgr.Real(10) self.iconst = self.mgr.Int(10) self.ftype = FunctionType(REAL, [REAL, REAL]) self.f = self.mgr.Symbol("f", self.ftype) self.real_expr = self.mgr.Plus(self.s, self.r) def test_new_fresh_symbol(self): fv1 = self.mgr.new_fresh_symbol(BOOL) self.assertIsNotNone(fv1, "New symbol was not created.") fv2 = self.mgr.new_fresh_symbol(BOOL) self.assertNotEqual(fv1, fv2, "Fresh symbol is not new.") fv3 = self.mgr.new_fresh_symbol(BOOL, "abc_%d") self.assertEqual(fv3.symbol_name()[:3], "abc", "Fresh variable doesn't have the desired prefix") def test_get_symbol(self): a = self.mgr.get_symbol("a") self.assertIsNone(a, "Symbol returned from an empty symboltable") self.mgr.get_or_create_symbol("a", BOOL) a = self.mgr.get_symbol("a") self.assertIsNotNone(a, "Symbol was not found in symbol table") def test_get_or_create_symbol(self): a = self.mgr.get_or_create_symbol("a", REAL) self.assertIsNotNone(a, "Symbol was not created") a2 = self.mgr.get_or_create_symbol("a", REAL) self.assertEqual(a, a2, "Symbol was not memoized") with self.assertRaises(TypeError): self.mgr.get_or_create_symbol("a", BOOL) def test_symbol(self): a1 = self.mgr.Symbol("a", BOOL) self.assertIsNotNone(a1, "Symbol was not created.") a2 = self.mgr.Symbol("a", BOOL) self.assertEqual(a1, a2, "Symbol is not memoized") c = self.mgr.Symbol("c") self.assertEqual(c.symbol_type(), BOOL, "Default Symbol Type is not BOOL") def test_and_node(self): n = self.mgr.And(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_and()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) m = self.mgr.And([self.x, self.y]) self.assertEqual(m, n, "And(1,2) != And([1,2]") args = m.args() self.assertTrue(self.x in args and self.y in args) self.assertTrue(len(args) == 2) zero = self.mgr.And() self.assertEqual(zero, self.mgr.TRUE()) one = self.mgr.And(self.x) self.assertEqual(one, self.x) def test_or_node(self): n = self.mgr.Or(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_or()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) m = self.mgr.Or([self.x, self.y]) self.assertEqual(m, n, "Or(1,2) != Or([1,2]") args = m.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 2) zero = self.mgr.Or() self.assertEqual(zero, self.mgr.FALSE()) one = self.mgr.Or(self.x) self.assertEqual(one, self.x) def test_not_node(self): n = self.mgr.Not(self.x) self.assertIsNotNone(n) self.assertTrue(n.is_not()) self.assertEqual(n.get_free_variables(), set([self.x])) args = n.args() self.assertIn(self.x, args) self.assertEqual(len(args), 1) self.assertEqual(self.mgr.Not(n), self.x) def test_implies_node(self): n = self.mgr.Implies(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_implies()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) args = n.args() self.assertEqual(self.x, args[0]) self.assertEqual(self.y, args[1]) self.assertEqual(len(args), 2) def test_iff_node(self): n = self.mgr.Iff(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_iff()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) args = n.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 2) def test_ge_node_type(self): with self.assertRaises(TypeError): self.mgr.GE(self.x, self.r) with self.assertRaises(TypeError): self.mgr.GE(self.r, self.x) with self.assertRaises(TypeError): self.mgr.GE(self.p, self.r) def test_ge_node(self): n = self.mgr.GE(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.GE(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.GE(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.GE(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.GE(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.GE(self.p, self.q) self.assertIsNotNone(n) def test_minus_node(self): n = self.mgr.Minus(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.Minus(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Minus(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.Minus(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Minus(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Minus(self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_minus()) self.assertEqual(n.get_free_variables(), set([self.p, self.q])) with self.assertRaises(TypeError): n = self.mgr.Minus(self.r, self.q) def test_times_node(self): n = self.mgr.Times(self.real_expr, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.rconst, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.rconst, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Times(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_times()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) n = self.mgr.Times(self.iconst, self.q) self.assertIsNotNone(n) def test_div_non_linear(self): with self.assertRaises(NonLinearError): self.mgr.Div(self.r, self.s) with self.assertRaises(NonLinearError): self.mgr.Div(self.rconst, self.s) def test_div_node(self): n = self.mgr.Div(self.real_expr, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.s, self.rconst) self.assertIsNotNone(n) inv = self.mgr.Real((1, self.rconst.constant_value())) self.assertEqual(n, self.mgr.Times(self.s, inv)) def test_equals(self): n = self.mgr.Equals(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.Equals(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Equals(self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_equals()) self.assertEqual(n.get_free_variables(), set([self.p, self.q])) with self.assertRaises(TypeError): n = self.mgr.Equals(self.p, self.r) def test_gt_node_type(self): with self.assertRaises(TypeError): self.mgr.GT(self.x, self.r) with self.assertRaises(TypeError): self.mgr.GT(self.r, self.x) with self.assertRaises(TypeError): self.mgr.GT(self.r, self.p) def test_gt_node(self): n = self.mgr.GT(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.GT(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.GT(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.GT(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.GT(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.GT(self.p, self.q) self.assertIsNotNone(n) def test_le_node_type(self): with self.assertRaises(TypeError): self.mgr.LE(self.x, self.r) with self.assertRaises(TypeError): self.mgr.LE(self.r, self.x) def test_le_node(self): n = self.mgr.LE(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.LE(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.LE(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.LE(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.LE(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_le()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) def test_lt_node_type(self): with self.assertRaises(TypeError): self.mgr.LT(self.x, self.r) with self.assertRaises(TypeError): self.mgr.LT(self.r, self.x) def test_lt_node(self): n = self.mgr.LT(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.LT(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.LT(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.LT(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.LT(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_lt()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) def test_ite(self): n = self.mgr.Ite(self.x, self.y, self.x) self.assertIsNotNone(n) args = n.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 3) n = self.mgr.Ite(self.x, self.s, self.r) self.assertIsNotNone(n) n = self.mgr.Ite(self.x, self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_ite()) self.assertEqual(n.get_free_variables(), set([self.x, self.p, self.q])) with self.assertRaises(TypeError): self.mgr.Ite(self.x, self.p, self.r) def test_function(self): n = self.mgr.Function(self.f, [self.r, self.s]) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) self.assertTrue(n.is_function_application()) self.assertEqual(n.get_free_variables(), set([self.f, self.r, self.s])) def test_constant(self): n1 = self.mgr.Real(Fraction(100, 10)) self.assertIsNotNone(n1) self.assertTrue(n1.is_constant()) self.assertTrue(n1.is_real_constant()) n2 = self.mgr.Real((100, 10)) self.assertEqual(n1, n2, "Generation of constant does not provide a consistent result.") n3 = self.mgr.Real(10) self.assertEqual(n1, n3, "Generation of constant does not provide a consistent result.") n4 = self.mgr.Real(10.0) self.assertEqual(n1, n4, "Generation of constant does not provide a consistent result.") nd = self.mgr.Real(Fraction(100,1)) self.assertNotEqual(nd, n1) with self.assertRaises(TypeError): self.mgr.Real(True) nd = self.mgr.Int(10) self.assertIsNotNone(nd) self.assertTrue(nd.is_constant()) self.assertTrue(nd.is_int_constant()) def test_bconstant(self): n = self.mgr.Bool(True) m = self.mgr.Bool(False) self.assertIsNotNone(n) self.assertIsNotNone(m) self.assertNotEqual(n, m) self.assertTrue(n.is_constant()) self.assertTrue(n.is_bool_constant()) with self.assertRaises(TypeError): self.mgr.Bool(42) def test_plus_node(self): with self.assertRaises(TypeError): self.mgr.Plus([self.x, self.r]) with self.assertRaises(TypeError): self.mgr.Plus([self.p, self.r]) with self.assertRaises(TypeError): self.mgr.Plus() n1 = self.mgr.Plus([self.r, self.s]) n2 = self.mgr.Plus(self.r, self.s) self.assertIsNotNone(n1) self.assertIsNotNone(n2) self.assertEqual(n1, n2, "Constructed Plus expression do not match") self.assertTrue(n1.is_plus()) self.assertEqual(set([self.r, self.s]), n1.get_free_variables()) one = self.mgr.Plus([self.p]) self.assertEqual(one, self.p) def test_exactly_one(self): symbols = [ self.mgr.Symbol("s%d"%i, BOOL) for i in range(5) ] c = self.mgr.ExactlyOne(symbols) self.assertTrue(len(c.args()) > 1) t = self.mgr.Bool(True) c = c.substitute({symbols[0]: t, symbols[1]: t}).simplify() self.assertEqual(c, self.mgr.Bool(False), "ExactlyOne should not allow 2 symbols to be True") @skipIfNoSolverForLogic(QF_BOOL) def test_exactly_one_is_sat(self): symbols = [ self.mgr.Symbol("s%d"%i, BOOL) for i in range(5) ] c = self.mgr.ExactlyOne(symbols) all_zero = self.mgr.And([self.mgr.Iff(s, self.mgr.Bool(False)) for s in symbols]) test_zero = self.mgr.And(c, all_zero) self.assertFalse(is_sat(test_zero, logic=QF_BOOL), "ExactlyOne should not allow all symbols to be False") def test_at_most_one(self): symbols = [ self.mgr.Symbol("s%d"%i, BOOL) for i in range(5) ] c = self.mgr.AtMostOne(symbols) self.assertTrue(len(c.args()) > 1) t = self.mgr.Bool(True) c = c.substitute({symbols[0]: t, symbols[1]: t}).simplify() self.assertEqual(c, self.mgr.Bool(False), "AtMostOne should not allow two symbols to be True") def test_xor(self): xor1 = self.mgr.Xor(self.x, self.y) self.assertIsNotNone(xor1) with self.assertRaises(TypeError): self.mgr.Xor(self.p, self.q) xor_false = self.mgr.Xor(self.mgr.TRUE(), self.mgr.TRUE()).simplify() self.assertEqual(xor_false, self.mgr.FALSE(), "Xor should be False if both arguments are True") xor_true = self.mgr.Xor(self.mgr.TRUE(), self.mgr.FALSE()).simplify() self.assertEqual(xor_true, self.mgr.TRUE(), "Xor should be True if both arguments are False") def test_all_different(self): many = 5 symbols = [self.mgr.Symbol("s%d"%i, INT) for i in range(many) ] f = self.mgr.AllDifferent(symbols) one = self.mgr.Int(1) for i in xrange(many): for j in xrange(many): if i != j: c = f.substitute({symbols[i]: one, symbols[j]: one}).simplify() self.assertEqual(c, self.mgr.Bool(False), "AllDifferent should not allow 2 symbols "\ "to be 1") c = f.substitute({symbols[i]: self.mgr.Int(i) for i in xrange(many)}) self.assertEqual(c.simplify(), self.mgr.Bool(True), "AllDifferent should be tautological for a set " \ "of different values") def test_min(self): min1 = self.mgr.Min(self.p, Plus(self.q, self.mgr.Int(1))) self.assertIsNotNone(min1) with self.assertRaises(TypeError): self.mgr.Min(self.p, self.r) min_int = self.mgr.Min(self.mgr.Int(1), self.mgr.Int(2), self.mgr.Int(3)) self.assertEqual(min_int.simplify(), self.mgr.Int(1), "The minimum of 1, 2 and 3 should be 1") min_real = self.mgr.Min(self.mgr.Real(1), self.mgr.Real(2), self.mgr.Real(3)) self.assertEqual(min_real.simplify(), self.mgr.Real(1), "The minimum of 1.0, 2.0 and 3.0 should be 1.0") def test_max(self): max1 = self.mgr.Max(self.p, Plus(self.q, self.mgr.Int(1))) self.assertIsNotNone(max1) with self.assertRaises(TypeError): self.mgr.Max(self.p, self.r) max_int = self.mgr.Max(self.mgr.Int(1), self.mgr.Int(2), self.mgr.Int(3)) self.assertEqual(max_int.simplify(), self.mgr.Int(3), "The maximum of 1, 2 and 3 should be 3") max_real = self.mgr.Max(self.mgr.Real(1), self.mgr.Real(2), self.mgr.Real(3)) self.assertEqual(max_real.simplify(), self.mgr.Real(3), "The maximum of 1.0, 2.0 and 3.0 should be 3.0") def test_pickling(self): import pickle src_env = Environment() dst_env = Environment() src_mgr = src_env.formula_manager dst_mgr = dst_env.formula_manager a = src_mgr.Symbol("A") b = src_mgr.Symbol("B") f = src_mgr.And(a, src_mgr.Not(b)) self.assertEqual(str(f), "(A & (! B))", str(f)) serialized = pickle.dumps(f) f_new = pickle.loads(serialized) f_new = dst_mgr.normalize(f) args = f_new.args() self.assertEqual(str(args[0]), "A", "Expecting symbol A, " + "symbol %s found instead" % str(args[0])) a = dst_mgr.Symbol("A") b = dst_mgr.Symbol("B") g = dst_mgr.And(a, dst_mgr.Not(b)) # Contextualized formula is memoized self.assertEqual(f_new, g, "%s != %s" % (id(f_new), id(g))) # But it differs from the one in the other formula manager self.assertNotEqual(f_new, f) # Normalizing a formula in the same manager should not # be a problem f_new = src_mgr.normalize(f) self.assertEqual(f_new, f, "%s != %s" %(id(a),id(b))) def test_infix(self): x, y, p = self.x, self.y, self.p with self.assertRaises(Exception): x.Implies(y) get_env().enable_infix_notation = True self.assertEqual(Implies(x,y), x.Implies(y)) self.assertEqual(p + p, Plus(p,p)) self.assertEqual(p > p, GT(p,p)) get_env().enable_infix_notation = False def test_infix_extended(self): p, r, x, y = self.p, self.r, self.x, self.y get_env().enable_infix_notation = True self.assertEqual(Plus(p, Int(1)), p + 1) self.assertEqual(Plus(r, Real(1)), r + 1) self.assertEqual(Times(r, Real(1)), r * 1) self.assertEqual(Minus(p, Int(1)), p - 1) self.assertEqual(Minus(r, Real(1)), r - 1) self.assertEqual(Times(r, Real(1)), r * 1) self.assertEqual(Plus(r, Real(1.5)), r + 1.5) self.assertEqual(Minus(r, Real(1.5)), r - 1.5) self.assertEqual(Times(r, Real(1.5)), r * 1.5) self.assertEqual(Plus(r, Real(1.5)), 1.5 + r) self.assertEqual(Times(r, Real(1.5)), 1.5 * r) with self.assertRaises(TypeError): foo = p + 1.5 self.assertEqual(Not(x), ~x) self.assertEqual(Times(r, Real(-1)), -r) self.assertEqual(Times(p, Int(-1)), -p) self.assertEqual(Xor(x, y), x ^ y) self.assertEqual(And(x, y), x & y) self.assertEqual(Or(x, y), x | y) self.assertEqual(Or(x, TRUE()), x | True) self.assertEqual(Or(x, TRUE()), True | x) self.assertEqual(And(x, TRUE()), x & True) self.assertEqual(And(x, TRUE()), True & x) get_env().enable_infix_notation = False def test_toReal(self): f = self.mgr.Equals(self.rconst, self.mgr.ToReal(self.p)) self.assertIsNotNone(f) with self.assertRaises(TypeError): self.mgr.ToReal(self.x) f1 = self.mgr.ToReal(self.p) f2 = self.mgr.ToReal(f1) self.assertEqual(f1, f2) self.assertTrue(f1.is_toreal()) self.assertEqual(set([self.p]), f1.get_free_variables()) f3 = self.mgr.Equals(self.iconst, self.p) with self.assertRaises(TypeError): self.mgr.ToReal(f3) f4 = self.mgr.Plus(self.rconst, self.r) f5 = self.mgr.ToReal(f4) self.assertEqual(f5, f4) def test_equals_or_iff(self): eq_1 = self.mgr.EqualsOrIff(self.p, self.q) eq_2 = self.mgr.Equals(self.p, self.q) self.assertEqual(eq_1, eq_2) iff_1 = self.mgr.EqualsOrIff(self.x, self.y) iff_2 = self.mgr.Iff(self.x, self.y) self.assertEqual(iff_1, iff_2) def test_is_term(self): and_x_x = self.mgr.And(self.x, self.x) apply_f = self.mgr.Function(self.f, [self.r, self.s]) self.assertTrue(self.x.is_term()) self.assertTrue(and_x_x.is_term()) self.assertFalse(self.f.is_term()) self.assertTrue(apply_f.is_term()) def test_formula_in_formula_manager(self): x = self.mgr.FreshSymbol() and_x_x = self.mgr.And(x, x) new_mgr = FormulaManager(get_env()) y = new_mgr.FreshSymbol() and_y_y = new_mgr.And(y, y) self.assertTrue(x in self.mgr) self.assertFalse(y in self.mgr) self.assertTrue(and_x_x in self.mgr) self.assertFalse(and_y_y in self.mgr) def test_typing(self): self.assertTrue(BOOL.is_bool_type()) self.assertFalse(BOOL.is_function_type()) self.assertTrue(REAL.is_real_type()) self.assertFalse(REAL.is_bool_type()) self.assertTrue(INT.is_int_type()) self.assertFalse(INT.is_real_type()) self.assertTrue(self.ftype.is_function_type()) self.assertFalse(self.ftype.is_int_type())
class TestFormulaManager(TestCase): def setUp(self): super(TestFormulaManager, self).setUp() self.env = get_env() self.mgr = self.env.formula_manager self.x = self.mgr.Symbol("x") self.y = self.mgr.Symbol("y") self.p = self.mgr.Symbol("p", INT) self.q = self.mgr.Symbol("q", INT) self.r = self.mgr.Symbol("r", REAL) self.s = self.mgr.Symbol("s", REAL) self.rconst = self.mgr.Real(10) self.iconst = self.mgr.Int(10) self.ftype = FunctionType(REAL, [REAL, REAL]) self.f = self.mgr.Symbol("f", self.ftype) self.real_expr = self.mgr.Plus(self.s, self.r) def test_new_fresh_symbol(self): fv1 = self.mgr.new_fresh_symbol(BOOL) self.assertIsNotNone(fv1, "New symbol was not created.") fv2 = self.mgr.new_fresh_symbol(BOOL) self.assertNotEqual(fv1, fv2, "Fresh symbol is not new.") fv3 = self.mgr.new_fresh_symbol(BOOL, "abc_%d") self.assertEqual(fv3.symbol_name()[:3], "abc", "Fresh variable doesn't have the desired prefix") def test_get_symbol(self): with self.assertRaises(UndefinedSymbolError): a = self.mgr.get_symbol("a") self.mgr.get_or_create_symbol("a", BOOL) a = self.mgr.get_symbol("a") self.assertIsNotNone(a, "Symbol was not found in symbol table") def test_get_or_create_symbol(self): a = self.mgr.get_or_create_symbol("a", REAL) self.assertIsNotNone(a, "Symbol was not created") a2 = self.mgr.get_or_create_symbol("a", REAL) self.assertEqual(a, a2, "Symbol was not memoized") with self.assertRaises(PysmtTypeError): self.mgr.get_or_create_symbol("a", BOOL) def test_symbol(self): a1 = self.mgr.Symbol("a", BOOL) self.assertIsNotNone(a1, "Symbol was not created.") a2 = self.mgr.Symbol("a", BOOL) self.assertEqual(a1, a2, "Symbol is not memoized") c = self.mgr.Symbol("c") self.assertEqual(c.symbol_type(), BOOL, "Default Symbol Type is not BOOL") def test_payload_assertions(self): s = self.mgr.Symbol("x") c = self.mgr.Int(0) with self.assertRaises(AssertionError): c.symbol_name() with self.assertRaises(AssertionError): c.symbol_type() with self.assertRaises(AssertionError): s.bv_width() with self.assertRaises(AssertionError): s.bv_extract_start() with self.assertRaises(AssertionError): s.bv_extract_end() with self.assertRaises(AssertionError): s.bv_rotation_step() with self.assertRaises(AssertionError): s.bv_extend_step() with self.assertRaises(AssertionError): s.bv_extract_end() with self.assertRaises(AssertionError): s.constant_value() with self.assertRaises(AssertionError): s.array_value_index_type() with self.assertRaises(AssertionError): s.function_name() def test_and_node(self): n = self.mgr.And(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_and()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) m = self.mgr.And([self.x, self.y]) self.assertEqual(m, n, "And(1,2) != And([1,2]") args = m.args() self.assertTrue(self.x in args and self.y in args) self.assertTrue(len(args) == 2) zero = self.mgr.And() self.assertEqual(zero, self.mgr.TRUE()) one = self.mgr.And(self.x) self.assertEqual(one, self.x) self.assertTrue(n.is_bool_op()) def test_or_node(self): n = self.mgr.Or(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_or()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) m = self.mgr.Or([self.x, self.y]) self.assertEqual(m, n, "Or(1,2) != Or([1,2]") args = m.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 2) zero = self.mgr.Or() self.assertEqual(zero, self.mgr.FALSE()) one = self.mgr.Or(self.x) self.assertEqual(one, self.x) self.assertTrue(n.is_bool_op()) def test_not_node(self): n = self.mgr.Not(self.x) self.assertIsNotNone(n) self.assertTrue(n.is_not()) self.assertEqual(n.get_free_variables(), set([self.x])) args = n.args() self.assertIn(self.x, args) self.assertEqual(len(args), 1) self.assertEqual(self.mgr.Not(n), self.x) self.assertTrue(n.is_bool_op()) def test_implies_node(self): n = self.mgr.Implies(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_implies()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) args = n.args() self.assertEqual(self.x, args[0]) self.assertEqual(self.y, args[1]) self.assertEqual(len(args), 2) self.assertTrue(n.is_bool_op()) def test_iff_node(self): n = self.mgr.Iff(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_iff()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) args = n.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 2) self.assertTrue(n.is_bool_op()) def test_ge_node_type(self): with self.assertRaises(PysmtTypeError): self.mgr.GE(self.x, self.r) with self.assertRaises(PysmtTypeError): self.mgr.GE(self.r, self.x) with self.assertRaises(PysmtTypeError): self.mgr.GE(self.p, self.r) def test_ge_node(self): n = self.mgr.GE(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.GE(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.GE(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.GE(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.GE(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.GE(self.p, self.q) self.assertIsNotNone(n) self.assertFalse(n.is_bool_op()) self.assertTrue(n.is_theory_relation()) def test_minus_node(self): n = self.mgr.Minus(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.Minus(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Minus(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.Minus(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Minus(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Minus(self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_minus()) self.assertEqual(n.get_free_variables(), set([self.p, self.q])) self.assertTrue(n.is_theory_op()) with self.assertRaises(PysmtTypeError): n = self.mgr.Minus(self.r, self.q) def test_times_node(self): n = self.mgr.Times(self.real_expr, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.r, self.s, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times([self.r, self.s, self.rconst]) self.assertIsNotNone(n) n = self.mgr.Times(x for x in [self.r, self.s, self.rconst]) self.assertIsNotNone(n) n = self.mgr.Times(self.rconst, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.rconst, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Times(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_times()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) n = self.mgr.Times(self.iconst, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_ira_op()) def test_div_node(self): n = self.mgr.Div(self.real_expr, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.s, self.rconst) self.assertIsNotNone(n) inv = self.mgr.Real(Fraction(1) / self.rconst.constant_value()) self.assertEqual(n, self.mgr.Times(self.s, inv)) def test_equals(self): n = self.mgr.Equals(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.Equals(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Equals(self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_equals()) self.assertEqual(n.get_free_variables(), set([self.p, self.q])) self.assertTrue(n.is_theory_relation()) with self.assertRaises(PysmtTypeError): n = self.mgr.Equals(self.p, self.r) def test_gt_node_type(self): with self.assertRaises(PysmtTypeError): self.mgr.GT(self.x, self.r) with self.assertRaises(PysmtTypeError): self.mgr.GT(self.r, self.x) with self.assertRaises(PysmtTypeError): self.mgr.GT(self.r, self.p) def test_gt_node(self): n = self.mgr.GT(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.GT(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.GT(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.GT(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.GT(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.GT(self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_theory_relation()) def test_le_node_type(self): with self.assertRaises(PysmtTypeError): self.mgr.LE(self.x, self.r) with self.assertRaises(PysmtTypeError): self.mgr.LE(self.r, self.x) def test_le_node(self): n = self.mgr.LE(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.LE(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.LE(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.LE(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.LE(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_le()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) self.assertTrue(n.is_theory_relation()) def test_lt_node_type(self): with self.assertRaises(PysmtTypeError): self.mgr.LT(self.x, self.r) with self.assertRaises(PysmtTypeError): self.mgr.LT(self.r, self.x) def test_lt_node(self): n = self.mgr.LT(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.LT(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.LT(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.LT(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.LT(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_lt()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) self.assertTrue(n.is_theory_relation()) def test_ite(self): n = self.mgr.Ite(self.x, self.y, self.x) self.assertIsNotNone(n) args = n.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 3) n = self.mgr.Ite(self.x, self.s, self.r) self.assertIsNotNone(n) n = self.mgr.Ite(self.x, self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_ite()) self.assertEqual(n.get_free_variables(), set([self.x, self.p, self.q])) with self.assertRaises(PysmtTypeError): self.mgr.Ite(self.x, self.p, self.r) def test_function(self): n = self.mgr.Function(self.f, [self.r, self.s]) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) self.assertTrue(n.is_function_application()) self.assertEqual(n.get_free_variables(), set([self.f, self.r, self.s])) def test_0arity_function(self): # Calling FunctionType on a 0-arity list of parameters returns # the type itself. t = FunctionType(REAL, []) # After this call: t = REAL # s1 is a symbol of type real s1 = self.mgr.Symbol("s1", t) s1b = self.mgr.Function(s1, []) self.assertEqual(s1, s1b) def test_constant(self): n1 = self.mgr.Real(Fraction(100, 10)) self.assertIsNotNone(n1) self.assertTrue(n1.is_constant()) self.assertTrue(n1.is_real_constant()) n2 = self.mgr.Real((100, 10)) self.assertEqual( n1, n2, "Generation of constant does not provide a consistent result.") n3 = self.mgr.Real(10) self.assertEqual( n1, n3, "Generation of constant does not provide a consistent result.") n4 = self.mgr.Real(10.0) self.assertEqual( n1, n4, "Generation of constant does not provide a consistent result.") nd = self.mgr.Real(Fraction(100, 1)) self.assertNotEqual(nd, n1) with self.assertRaises(PysmtTypeError): self.mgr.Real(True) nd = self.mgr.Int(10) self.assertIsNotNone(nd) self.assertTrue(nd.is_constant()) self.assertTrue(nd.is_int_constant()) # Memoization of constants a = self.mgr.Real(Fraction(1, 2)) b = self.mgr.Real((1, 2)) c = self.mgr.Real(1.0 / 2.0) self.assertEqual(a, b) self.assertEqual(b, c) # Constant's Type b = self.mgr.Bool(True) i = self.mgr.Int(1) r = self.mgr.Real(1) bv8 = self.mgr.BV(1, 8) self.assertEqual(i.constant_type(), INT) self.assertEqual(r.constant_type(), REAL) self.assertEqual(bv8.constant_type(), BV8) self.assertEqual(b.constant_type(), BOOL) def test_bconstant(self): n = self.mgr.Bool(True) m = self.mgr.Bool(False) self.assertIsNotNone(n) self.assertIsNotNone(m) self.assertNotEqual(n, m) self.assertTrue(n.is_constant()) self.assertTrue(n.is_bool_constant()) with self.assertRaises(PysmtTypeError): self.mgr.Bool(42) def test_plus_node(self): with self.assertRaises(PysmtTypeError): self.mgr.Plus([self.x, self.r]) with self.assertRaises(PysmtTypeError): self.mgr.Plus([self.p, self.r]) with self.assertRaises(PysmtTypeError): self.mgr.Plus() n1 = self.mgr.Plus([self.r, self.s]) n2 = self.mgr.Plus(self.r, self.s) self.assertIsNotNone(n1) self.assertIsNotNone(n2) self.assertEqual(n1, n2, "Constructed Plus expression do not match") self.assertTrue(n1.is_plus()) self.assertEqual(set([self.r, self.s]), n1.get_free_variables()) one = self.mgr.Plus([self.p]) self.assertEqual(one, self.p) def test_exactly_one(self): symbols = [self.mgr.Symbol("s%d" % i, BOOL) for i in range(5)] c = self.mgr.ExactlyOne(symbols) self.assertTrue(len(c.args()) > 1) t = self.mgr.Bool(True) c = c.substitute({symbols[0]: t, symbols[1]: t}).simplify() self.assertEqual(c, self.mgr.Bool(False), "ExactlyOne should not allow 2 symbols to be True") s1 = self.mgr.Symbol("x") s2 = self.mgr.Symbol("x") f1 = self.mgr.ExactlyOne((s for s in [s1, s2])) f2 = self.mgr.ExactlyOne([s1, s2]) f3 = self.mgr.ExactlyOne(s1, s2) self.assertEqual(f1, f2) self.assertEqual(f2, f3) @skipIfNoSolverForLogic(QF_BOOL) def test_exactly_one_is_sat(self): symbols = [self.mgr.Symbol("s%d" % i, BOOL) for i in range(5)] c = self.mgr.ExactlyOne(symbols) all_zero = self.mgr.And( [self.mgr.Iff(s, self.mgr.Bool(False)) for s in symbols]) test_zero = self.mgr.And(c, all_zero) self.assertFalse( is_sat(test_zero, logic=QF_BOOL), "ExactlyOne should not allow all symbols to be False") def test_at_most_one(self): symbols = [self.mgr.Symbol("s%d" % i, BOOL) for i in range(5)] c = self.mgr.AtMostOne(symbols) self.assertTrue(len(c.args()) > 1) t = self.mgr.Bool(True) c = c.substitute({symbols[0]: t, symbols[1]: t}).simplify() self.assertEqual(c, self.mgr.Bool(False), "AtMostOne should not allow two symbols to be True") def test_xor(self): xor1 = self.mgr.Xor(self.x, self.y) self.assertIsNotNone(xor1) with self.assertRaises(PysmtTypeError): self.mgr.Xor(self.p, self.q) xor_false = self.mgr.Xor(self.mgr.TRUE(), self.mgr.TRUE()).simplify() self.assertEqual(xor_false, self.mgr.FALSE(), "Xor should be False if both arguments are True") xor_true = self.mgr.Xor(self.mgr.TRUE(), self.mgr.FALSE()).simplify() self.assertEqual(xor_true, self.mgr.TRUE(), "Xor should be True if both arguments are False") def test_all_different(self): many = 5 symbols = [self.mgr.Symbol("s%d" % i, INT) for i in range(many)] f = self.mgr.AllDifferent(symbols) one = self.mgr.Int(1) for i in xrange(many): for j in xrange(many): if i != j: c = f.substitute({ symbols[i]: one, symbols[j]: one }).simplify() self.assertEqual(c, self.mgr.Bool(False), "AllDifferent should not allow 2 symbols "\ "to be 1") c = f.substitute( dict((symbols[i], self.mgr.Int(i)) for i in xrange(many))) self.assertEqual(c.simplify(), self.mgr.Bool(True), "AllDifferent should be tautological for a set " \ "of different values") def test_min(self): min1 = self.mgr.Min(self.p, Plus(self.q, self.mgr.Int(1))) self.assertIsNotNone(min1) with self.assertRaises(PysmtTypeError): self.mgr.Min(self.p, self.r) min_int = self.mgr.Min(self.mgr.Int(1), self.mgr.Int(2), self.mgr.Int(3)) self.assertEqual(min_int.simplify(), self.mgr.Int(1), "The minimum of 1, 2 and 3 should be 1") min_real = self.mgr.Min(self.mgr.Real(1), self.mgr.Real(2), self.mgr.Real(3)) self.assertEqual(min_real.simplify(), self.mgr.Real(1), "The minimum of 1.0, 2.0 and 3.0 should be 1.0") def test_max(self): max1 = self.mgr.Max(self.p, Plus(self.q, self.mgr.Int(1))) self.assertIsNotNone(max1) with self.assertRaises(PysmtTypeError): self.mgr.Max(self.p, self.r) max_int = self.mgr.Max(self.mgr.Int(1), self.mgr.Int(2), self.mgr.Int(3)) self.assertEqual(max_int.simplify(), self.mgr.Int(3), "The maximum of 1, 2 and 3 should be 3") max_real = self.mgr.Max(self.mgr.Real(1), self.mgr.Real(2), self.mgr.Real(3)) self.assertEqual(max_real.simplify(), self.mgr.Real(3), "The maximum of 1.0, 2.0 and 3.0 should be 3.0") def test_pickling(self): import pickle src_env = Environment() dst_env = Environment() src_mgr = src_env.formula_manager dst_mgr = dst_env.formula_manager a = src_mgr.Symbol("A") b = src_mgr.Symbol("B") f = src_mgr.And(a, src_mgr.Not(b)) self.assertEqual(str(f), "(A & (! B))", str(f)) # NOTE: We cannot use the textual format for pickle, because # we are using slots. We can, however, use more advanced # versions of pickle. Therefore, we specify here to use the # latest protocol. serialized = pickle.dumps(f, pickle.HIGHEST_PROTOCOL) f_new = pickle.loads(serialized) f_new = dst_mgr.normalize(f) args = f_new.args() self.assertEqual( str(args[0]), "A", "Expecting symbol A, " + "symbol %s found instead" % str(args[0])) a = dst_mgr.Symbol("A") b = dst_mgr.Symbol("B") g = dst_mgr.And(a, dst_mgr.Not(b)) # Contextualized formula is memoized self.assertEqual(f_new, g, "%s != %s" % (id(f_new), id(g))) # But it differs from the one in the other formula manager self.assertNotEqual(f_new, f) # Normalizing a formula in the same manager should not # be a problem f_new = src_mgr.normalize(f) self.assertEqual(f_new, f, "%s != %s" % (id(a), id(b))) def test_infix(self): x, y, p = self.x, self.y, self.p with self.assertRaises(PysmtModeError): x.Implies(y) with self.assertRaises(PysmtModeError): ~x with self.assertRaises(PysmtModeError): x[1] with self.assertRaises(PysmtModeError): x.Ite(x, y) get_env().enable_infix_notation = True self.assertEqual(Implies(x, y), x.Implies(y)) self.assertEqual(p + p, Plus(p, p)) self.assertEqual(p > p, GT(p, p)) with self.assertRaises(NotImplementedError): x[1] def test_infix_extended(self): p, r, x, y = self.p, self.r, self.x, self.y get_env().enable_infix_notation = True self.assertEqual(Plus(p, Int(1)), p + 1) self.assertEqual(Plus(r, Real(1)), r + 1) self.assertEqual(Times(r, Real(1)), r * 1) self.assertEqual(Minus(p, Int(1)), p - 1) self.assertEqual(Minus(r, Real(1)), r - 1) self.assertEqual(Times(r, Real(1)), r * 1) self.assertEqual(Plus(r, Real(1.5)), r + 1.5) self.assertEqual(Minus(r, Real(1.5)), r - 1.5) self.assertEqual(Times(r, Real(1.5)), r * 1.5) self.assertEqual(Plus(r, Real(1.5)), 1.5 + r) self.assertEqual(Times(r, Real(1.5)), 1.5 * r) with self.assertRaises(PysmtTypeError): foo = p + 1.5 self.assertEqual(Not(x), ~x) self.assertEqual(Times(r, Real(-1)), -r) self.assertEqual(Times(p, Int(-1)), -p) self.assertEqual(Xor(x, y), x ^ y) self.assertEqual(And(x, y), x & y) self.assertEqual(Or(x, y), x | y) self.assertEqual(Or(x, TRUE()), x | True) self.assertEqual(Or(x, TRUE()), True | x) self.assertEqual(And(x, TRUE()), x & True) self.assertEqual(And(x, TRUE()), True & x) self.assertEqual(Iff(x, y), x.Iff(y)) self.assertEqual(And(x, y), x.And(y)) self.assertEqual(Or(x, y), x.Or(y)) self.assertEqual(Ite(x, TRUE(), FALSE()), x.Ite(TRUE(), FALSE())) with self.assertRaises(Exception): x.Ite(1, 2) self.assertEqual(6 - r, Plus(Times(r, Real(-1)), Real(6))) # BVs # BV_CONSTANT: We use directly python numbers # # Note: In this case, the width is implicit (yikes!) The # width of the constant is inferred by the use of a # symbol or operator that enforces a bit_width. # # This works in very simple cases. For complex # expressions it is advisable to create a shortcut for # the given BVType. const1 = 3 const2 = 0b011 const3 = 0x3 # Since these are python numbers, the following holds self.assertEqual(const1, const2) self.assertEqual(const1, const3) # However, we cannot use infix pySMT Equals, since const1 is a # python int!!! with self.assertRaises(AttributeError): const1.Equals(const2) # We use the usual syntax to build a constant with a fixed width const1_8 = self.mgr.BV(3, width=8) # In actual code, one can simply create a macro for this: _8bv = lambda v: self.mgr.BV(v, width=8) const1_8b = _8bv(3) self.assertEqual(const1_8, const1_8b) # Equals forces constants to have the width of the operand self.assertEqual(const1_8.Equals(const1), self.mgr.Equals(const1_8, const1_8b)) # Symbols bv8 = self.mgr.FreshSymbol(BV8) bv7 = self.mgr.FreshSymbol(BVType(7)) self.assertEqual(bv8.Equals(const1), bv8.Equals(const1_8)) # BV_AND, self.assertEqual(bv8 & const1, self.mgr.BVAnd(bv8, const1_8)) self.assertEqual(const1 & bv8, self.mgr.BVAnd(bv8, const1_8)) self.assertEqual(const1 & bv8, self.mgr.BVAnd(bv8, const1_8)) # BV_XOR, self.assertEqual(bv8 ^ const1, self.mgr.BVXor(bv8, const1_8)) self.assertEqual(const1 ^ bv8, self.mgr.BVXor(bv8, const1_8)) # BV_OR, self.assertEqual(bv8 | const1, self.mgr.BVOr(bv8, const1_8)) self.assertEqual(const1 | bv8, self.mgr.BVOr(bv8, const1_8)) # BV_ADD, self.assertEqual(bv8 + const1, self.mgr.BVAdd(bv8, const1_8)) self.assertEqual(const1 + bv8, self.mgr.BVAdd(bv8, const1_8)) # BV_SUB, self.assertEqual(bv8 - const1, self.mgr.BVSub(bv8, const1_8)) self.assertEqual(const1 - bv8, self.mgr.BVSub(const1_8, bv8)) # BV_MUL, self.assertEqual(bv8 * const1, self.mgr.BVMul(bv8, const1_8)) self.assertEqual(const1 * bv8, self.mgr.BVMul(bv8, const1_8)) # BV_NOT: # !!!WARNING!!! Cannot be applied to python constants!! # This results in a negative number with self.assertRaises(PysmtValueError): _8bv(~const1) # For symbols and expressions this works as expected self.assertEqual(~bv8, self.mgr.BVNot(bv8)) # BV_NEG -- Cannot be applied to 'infix' constants self.assertEqual(-bv8, self.mgr.BVNeg(bv8)) # BV_EXTRACT -- Cannot be applied to 'infix' constants self.assertEqual(bv8[0:7], self.mgr.BVExtract(bv8, 0, 7)) self.assertEqual(bv8[:7], self.mgr.BVExtract(bv8, end=7)) self.assertEqual(bv8[0:], self.mgr.BVExtract(bv8, start=0)) self.assertEqual(bv8[7], self.mgr.BVExtract(bv8, start=7, end=7)) # BV_ULT, self.assertEqual(bv8 < const1, self.mgr.BVULT(bv8, const1_8)) # BV_ULE, self.assertEqual(bv8 <= const1, self.mgr.BVULE(bv8, const1_8)) # BV_UGT self.assertEqual(bv8 > const1, self.mgr.BVUGT(bv8, const1_8)) # BV_UGE self.assertEqual(bv8 >= const1, self.mgr.BVUGE(bv8, const1_8)) # BV_LSHL, self.assertEqual(bv8 << const1, self.mgr.BVLShl(bv8, const1_8)) # BV_LSHR, self.assertEqual(bv8 >> const1, self.mgr.BVLShr(bv8, const1_8)) # BV_UDIV, self.assertEqual(bv8 / const1, self.mgr.BVUDiv(bv8, const1_8)) # BV_UREM, self.assertEqual(bv8 % const1, self.mgr.BVURem(bv8, const1_8)) # The following operators use the infix syntax left.Operator.right # These includes all signed operators # BVSLT, self.assertEqual(self.mgr.BVSLT(bv8, const1_8), bv8.BVSLT(const1_8)) #BVSLE, self.assertEqual(self.mgr.BVSLE(bv8, const1_8), bv8.BVSLE(const1_8)) #BVComp self.assertEqual(self.mgr.BVComp(bv8, const1_8), bv8.BVComp(const1_8)) #BVSDiv self.assertEqual(self.mgr.BVSDiv(bv8, const1_8), bv8.BVSDiv(const1_8)) #BVSRem self.assertEqual(self.mgr.BVSRem(bv8, const1_8), bv8.BVSRem(const1_8)) #BVAShr self.assertEqual(self.mgr.BVAShr(bv8, const1_8), bv8.BVAShr(const1_8)) #BVNand self.assertEqual(self.mgr.BVNand(bv8, const1_8), bv8.BVNand(const1_8)) #BVNor self.assertEqual(self.mgr.BVNor(bv8, const1_8), bv8.BVNor(const1_8)) #BVXnor self.assertEqual(self.mgr.BVXnor(bv8, const1_8), bv8.BVXnor(const1_8)) #BVSGT self.assertEqual(self.mgr.BVSGT(bv8, const1_8), bv8.BVSGT(const1_8)) #BVSGE self.assertEqual(self.mgr.BVSGE(bv8, const1_8), bv8.BVSGE(const1_8)) #BVSMod self.assertEqual(self.mgr.BVSMod(bv8, const1_8), bv8.BVSMod(const1_8)) #BVRol, self.assertEqual(self.mgr.BVRol(bv8, steps=5), bv8.BVRol(5)) #BVRor, self.assertEqual(self.mgr.BVRor(bv8, steps=5), bv8.BVRor(5)) #BVZExt, self.assertEqual(self.mgr.BVZExt(bv8, increase=4), bv8.BVZExt(4)) #BVSExt, self.assertEqual(self.mgr.BVSExt(bv8, increase=4), bv8.BVSExt(4)) #BVRepeat, self.assertEqual(self.mgr.BVRepeat(bv8, count=5), bv8.BVRepeat(5)) def test_toReal(self): f = self.mgr.Equals(self.rconst, self.mgr.ToReal(self.p)) self.assertIsNotNone(f) with self.assertRaises(PysmtTypeError): self.mgr.ToReal(self.x) f1 = self.mgr.ToReal(self.p) f2 = self.mgr.ToReal(f1) self.assertEqual(f1, f2) self.assertTrue(f1.is_toreal()) self.assertEqual(set([self.p]), f1.get_free_variables()) f3 = self.mgr.Equals(self.iconst, self.p) with self.assertRaises(PysmtTypeError): self.mgr.ToReal(f3) f4 = self.mgr.Plus(self.rconst, self.r) f5 = self.mgr.ToReal(f4) self.assertEqual(f5, f4) def test_equals_or_iff(self): eq_1 = self.mgr.EqualsOrIff(self.p, self.q) eq_2 = self.mgr.Equals(self.p, self.q) self.assertEqual(eq_1, eq_2) iff_1 = self.mgr.EqualsOrIff(self.x, self.y) iff_2 = self.mgr.Iff(self.x, self.y) self.assertEqual(iff_1, iff_2) def test_is_term(self): and_x_x = self.mgr.And(self.x, self.x) apply_f = self.mgr.Function(self.f, [self.r, self.s]) self.assertTrue(self.x.is_term()) self.assertTrue(and_x_x.is_term()) self.assertFalse(self.f.is_term()) self.assertTrue(apply_f.is_term()) def test_formula_in_formula_manager(self): x = self.mgr.FreshSymbol() and_x_x = self.mgr.And(x, x) new_mgr = FormulaManager(get_env()) y = new_mgr.FreshSymbol() and_y_y = new_mgr.And(y, y) self.assertTrue(x in self.mgr) self.assertFalse(y in self.mgr) self.assertTrue(and_x_x in self.mgr) self.assertFalse(and_y_y in self.mgr) def test_typing(self): self.assertTrue(BOOL.is_bool_type()) self.assertFalse(BOOL.is_function_type()) self.assertTrue(REAL.is_real_type()) self.assertFalse(REAL.is_bool_type()) self.assertTrue(INT.is_int_type()) self.assertFalse(INT.is_real_type()) self.assertTrue(self.ftype.is_function_type()) self.assertFalse(self.ftype.is_int_type()) def test_array_value(self): a1 = self.mgr.Array(INT, self.mgr.Int(0)) a2 = self.mgr.Array(INT, self.mgr.Int(0), {self.mgr.Int(12): self.mgr.Int(0)}) self.assertEqual(a1, a2) def test_real(self): """Create Real using different constant types.""" from fractions import Fraction as pyFraction from pysmt.constants import HAS_GMPY v1 = (1, 2) v2 = 0.5 v3 = pyFraction(1, 2) v4 = Fraction(1, 2) c1 = self.mgr.Real(v1) c2 = self.mgr.Real(v2) c3 = self.mgr.Real(v3) c4 = self.mgr.Real(v4) self.assertIs(c1, c2) self.assertIs(c2, c3) self.assertIs(c3, c4) if HAS_GMPY: from gmpy2 import mpq, mpz v5 = (mpz(1), mpz(2)) v6 = mpq(1, 2) c5 = self.mgr.Real(v5) c6 = self.mgr.Real(v6) self.assertIs(c4, c5) self.assertIs(c5, c6) def test_integer(self): """Create Int using different constant types.""" from pysmt.constants import HAS_GMPY from six import PY2 v_base = Integer(1) c_base = self.mgr.Int(v_base) v_int = int(1) c_int = self.mgr.Int(v_int) self.assertIs(c_base, c_int) if PY2: v_long = long(1) c_long = self.mgr.Int(v_long) self.assertIs(c_base, c_long) if HAS_GMPY: from gmpy2 import mpz v_mpz = mpz(1) c_mpz = self.mgr.Int(v_mpz) self.assertIs(c_base, c_mpz) def test_node_id(self): x = Symbol("x") y = Symbol("y") xx = Symbol("x") self.assertEqual(x.node_id(), xx.node_id()) self.assertNotEqual(x.node_id(), y.node_id())
class TestFormulaManager(TestCase): def setUp(self): super(TestFormulaManager, self).setUp() self.env = get_env() self.mgr = self.env.formula_manager self.x = self.mgr.Symbol("x") self.y = self.mgr.Symbol("y") self.p = self.mgr.Symbol("p", INT) self.q = self.mgr.Symbol("q", INT) self.r = self.mgr.Symbol("r", REAL) self.s = self.mgr.Symbol("s", REAL) self.rconst = self.mgr.Real(10) self.iconst = self.mgr.Int(10) self.ftype = FunctionType(REAL, [REAL, REAL]) self.f = self.mgr.Symbol("f", self.ftype) self.real_expr = self.mgr.Plus(self.s, self.r) def test_new_fresh_symbol(self): fv1 = self.mgr.new_fresh_symbol(BOOL) self.assertIsNotNone(fv1, "New symbol was not created.") fv2 = self.mgr.new_fresh_symbol(BOOL) self.assertNotEqual(fv1, fv2, "Fresh symbol is not new.") fv3 = self.mgr.new_fresh_symbol(BOOL, "abc_%d") self.assertEqual(fv3.symbol_name()[:3], "abc", "Fresh variable doesn't have the desired prefix") def test_get_symbol(self): a = self.mgr.get_symbol("a") self.assertIsNone(a, "Symbol returned from an empty symboltable") self.mgr.get_or_create_symbol("a", BOOL) a = self.mgr.get_symbol("a") self.assertIsNotNone(a, "Symbol was not found in symbol table") def test_get_or_create_symbol(self): a = self.mgr.get_or_create_symbol("a", REAL) self.assertIsNotNone(a, "Symbol was not created") a2 = self.mgr.get_or_create_symbol("a", REAL) self.assertEqual(a, a2, "Symbol was not memoized") with self.assertRaises(TypeError): self.mgr.get_or_create_symbol("a", BOOL) def test_symbol(self): a1 = self.mgr.Symbol("a", BOOL) self.assertIsNotNone(a1, "Symbol was not created.") a2 = self.mgr.Symbol("a", BOOL) self.assertEqual(a1, a2, "Symbol is not memoized") c = self.mgr.Symbol("c") self.assertEqual(c.symbol_type(), BOOL, "Default Symbol Type is not BOOL") def test_and_node(self): n = self.mgr.And(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_and()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) m = self.mgr.And([self.x, self.y]) self.assertEqual(m, n, "And(1,2) != And([1,2]") args = m.args() self.assertTrue(self.x in args and self.y in args) self.assertTrue(len(args) == 2) zero = self.mgr.And() self.assertEqual(zero, self.mgr.TRUE()) one = self.mgr.And(self.x) self.assertEqual(one, self.x) def test_or_node(self): n = self.mgr.Or(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_or()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) m = self.mgr.Or([self.x, self.y]) self.assertEqual(m, n, "Or(1,2) != Or([1,2]") args = m.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 2) zero = self.mgr.Or() self.assertEqual(zero, self.mgr.FALSE()) one = self.mgr.Or(self.x) self.assertEqual(one, self.x) def test_not_node(self): n = self.mgr.Not(self.x) self.assertIsNotNone(n) self.assertTrue(n.is_not()) self.assertEqual(n.get_free_variables(), set([self.x])) args = n.args() self.assertIn(self.x, args) self.assertEqual(len(args), 1) self.assertEqual(self.mgr.Not(n), self.x) def test_implies_node(self): n = self.mgr.Implies(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_implies()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) args = n.args() self.assertEqual(self.x, args[0]) self.assertEqual(self.y, args[1]) self.assertEqual(len(args), 2) def test_iff_node(self): n = self.mgr.Iff(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_iff()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) args = n.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 2) def test_ge_node_type(self): with self.assertRaises(TypeError): self.mgr.GE(self.x, self.r) with self.assertRaises(TypeError): self.mgr.GE(self.r, self.x) with self.assertRaises(TypeError): self.mgr.GE(self.p, self.r) def test_ge_node(self): n = self.mgr.GE(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.GE(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.GE(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.GE(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.GE(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.GE(self.p, self.q) self.assertIsNotNone(n) def test_minus_node(self): n = self.mgr.Minus(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.Minus(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Minus(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.Minus(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Minus(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Minus(self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_minus()) self.assertEqual(n.get_free_variables(), set([self.p, self.q])) with self.assertRaises(TypeError): n = self.mgr.Minus(self.r, self.q) def test_times_node(self): n = self.mgr.Times(self.real_expr, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.rconst, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.rconst, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Times(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_times()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) n = self.mgr.Times(self.iconst, self.q) self.assertIsNotNone(n) def test_div_non_linear(self): with self.assertRaises(NonLinearError): self.mgr.Div(self.r, self.s) with self.assertRaises(NonLinearError): self.mgr.Div(self.rconst, self.s) def test_div_node(self): n = self.mgr.Div(self.real_expr, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.s, self.rconst) self.assertIsNotNone(n) inv = self.mgr.Real((1, self.rconst.constant_value())) self.assertEqual(n, self.mgr.Times(self.s, inv)) def test_equals(self): n = self.mgr.Equals(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.Equals(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Equals(self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_equals()) self.assertEqual(n.get_free_variables(), set([self.p, self.q])) with self.assertRaises(TypeError): n = self.mgr.Equals(self.p, self.r) def test_gt_node_type(self): with self.assertRaises(TypeError): self.mgr.GT(self.x, self.r) with self.assertRaises(TypeError): self.mgr.GT(self.r, self.x) with self.assertRaises(TypeError): self.mgr.GT(self.r, self.p) def test_gt_node(self): n = self.mgr.GT(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.GT(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.GT(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.GT(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.GT(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.GT(self.p, self.q) self.assertIsNotNone(n) def test_le_node_type(self): with self.assertRaises(TypeError): self.mgr.LE(self.x, self.r) with self.assertRaises(TypeError): self.mgr.LE(self.r, self.x) def test_le_node(self): n = self.mgr.LE(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.LE(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.LE(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.LE(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.LE(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_le()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) def test_lt_node_type(self): with self.assertRaises(TypeError): self.mgr.LT(self.x, self.r) with self.assertRaises(TypeError): self.mgr.LT(self.r, self.x) def test_lt_node(self): n = self.mgr.LT(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.LT(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.LT(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.LT(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.LT(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_lt()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) def test_ite(self): n = self.mgr.Ite(self.x, self.y, self.x) self.assertIsNotNone(n) args = n.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 3) n = self.mgr.Ite(self.x, self.s, self.r) self.assertIsNotNone(n) n = self.mgr.Ite(self.x, self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_ite()) self.assertEqual(n.get_free_variables(), set([self.x, self.p, self.q])) with self.assertRaises(TypeError): self.mgr.Ite(self.x, self.p, self.r) def test_function(self): n = self.mgr.Function(self.f, [self.r, self.s]) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) self.assertTrue(n.is_function_application()) self.assertEqual(n.get_free_variables(), set([self.f, self.r, self.s])) def test_constant(self): n1 = self.mgr.Real(Fraction(100, 10)) self.assertIsNotNone(n1) self.assertTrue(n1.is_constant()) self.assertTrue(n1.is_real_constant()) n2 = self.mgr.Real((100, 10)) self.assertEqual( n1, n2, "Generation of constant does not provide a consistent result.") n3 = self.mgr.Real(10) self.assertEqual( n1, n3, "Generation of constant does not provide a consistent result.") n4 = self.mgr.Real(10.0) self.assertEqual( n1, n4, "Generation of constant does not provide a consistent result.") nd = self.mgr.Real(Fraction(100, 1)) self.assertNotEqual(nd, n1) with self.assertRaises(TypeError): self.mgr.Real(True) nd = self.mgr.Int(10) self.assertIsNotNone(nd) self.assertTrue(nd.is_constant()) self.assertTrue(nd.is_int_constant()) def test_bconstant(self): n = self.mgr.Bool(True) m = self.mgr.Bool(False) self.assertIsNotNone(n) self.assertIsNotNone(m) self.assertNotEqual(n, m) self.assertTrue(n.is_constant()) self.assertTrue(n.is_bool_constant()) with self.assertRaises(TypeError): self.mgr.Bool(42) def test_plus_node(self): with self.assertRaises(TypeError): self.mgr.Plus([self.x, self.r]) with self.assertRaises(TypeError): self.mgr.Plus([self.p, self.r]) with self.assertRaises(TypeError): self.mgr.Plus() n1 = self.mgr.Plus([self.r, self.s]) n2 = self.mgr.Plus(self.r, self.s) self.assertIsNotNone(n1) self.assertIsNotNone(n2) self.assertEqual(n1, n2, "Constructed Plus expression do not match") self.assertTrue(n1.is_plus()) self.assertEqual(set([self.r, self.s]), n1.get_free_variables()) one = self.mgr.Plus([self.p]) self.assertEqual(one, self.p) def test_exactly_one(self): symbols = [self.mgr.Symbol("s%d" % i, BOOL) for i in range(5)] c = self.mgr.ExactlyOne(symbols) self.assertTrue(len(c.args()) > 1) t = self.mgr.Bool(True) c = c.substitute({symbols[0]: t, symbols[1]: t}).simplify() self.assertEqual(c, self.mgr.Bool(False), "ExactlyOne should not allow 2 symbols to be True") @skipIfNoSolverForLogic(QF_BOOL) def test_exactly_one_is_sat(self): symbols = [self.mgr.Symbol("s%d" % i, BOOL) for i in range(5)] c = self.mgr.ExactlyOne(symbols) all_zero = self.mgr.And( [self.mgr.Iff(s, self.mgr.Bool(False)) for s in symbols]) test_zero = self.mgr.And(c, all_zero) self.assertFalse( is_sat(test_zero, logic=QF_BOOL), "ExactlyOne should not allow all symbols to be False") def test_at_most_one(self): symbols = [self.mgr.Symbol("s%d" % i, BOOL) for i in range(5)] c = self.mgr.AtMostOne(symbols) self.assertTrue(len(c.args()) > 1) t = self.mgr.Bool(True) c = c.substitute({symbols[0]: t, symbols[1]: t}).simplify() self.assertEqual(c, self.mgr.Bool(False), "AtMostOne should not allow two symbols to be True") def test_xor(self): xor1 = self.mgr.Xor(self.x, self.y) self.assertIsNotNone(xor1) with self.assertRaises(TypeError): self.mgr.Xor(self.p, self.q) xor_false = self.mgr.Xor(self.mgr.TRUE(), self.mgr.TRUE()).simplify() self.assertEqual(xor_false, self.mgr.FALSE(), "Xor should be False if both arguments are True") xor_true = self.mgr.Xor(self.mgr.TRUE(), self.mgr.FALSE()).simplify() self.assertEqual(xor_true, self.mgr.TRUE(), "Xor should be True if both arguments are False") def test_all_different(self): many = 5 symbols = [self.mgr.Symbol("s%d" % i, INT) for i in range(many)] f = self.mgr.AllDifferent(symbols) one = self.mgr.Int(1) for i in xrange(many): for j in xrange(many): if i != j: c = f.substitute({ symbols[i]: one, symbols[j]: one }).simplify() self.assertEqual(c, self.mgr.Bool(False), "AllDifferent should not allow 2 symbols "\ "to be 1") c = f.substitute({symbols[i]: self.mgr.Int(i) for i in xrange(many)}) self.assertEqual(c.simplify(), self.mgr.Bool(True), "AllDifferent should be tautological for a set " \ "of different values") def test_min(self): min1 = self.mgr.Min(self.p, Plus(self.q, self.mgr.Int(1))) self.assertIsNotNone(min1) with self.assertRaises(TypeError): self.mgr.Min(self.p, self.r) min_int = self.mgr.Min(self.mgr.Int(1), self.mgr.Int(2), self.mgr.Int(3)) self.assertEqual(min_int.simplify(), self.mgr.Int(1), "The minimum of 1, 2 and 3 should be 1") min_real = self.mgr.Min(self.mgr.Real(1), self.mgr.Real(2), self.mgr.Real(3)) self.assertEqual(min_real.simplify(), self.mgr.Real(1), "The minimum of 1.0, 2.0 and 3.0 should be 1.0") def test_max(self): max1 = self.mgr.Max(self.p, Plus(self.q, self.mgr.Int(1))) self.assertIsNotNone(max1) with self.assertRaises(TypeError): self.mgr.Max(self.p, self.r) max_int = self.mgr.Max(self.mgr.Int(1), self.mgr.Int(2), self.mgr.Int(3)) self.assertEqual(max_int.simplify(), self.mgr.Int(3), "The maximum of 1, 2 and 3 should be 3") max_real = self.mgr.Max(self.mgr.Real(1), self.mgr.Real(2), self.mgr.Real(3)) self.assertEqual(max_real.simplify(), self.mgr.Real(3), "The maximum of 1.0, 2.0 and 3.0 should be 3.0") def test_pickling(self): import pickle src_env = Environment() dst_env = Environment() src_mgr = src_env.formula_manager dst_mgr = dst_env.formula_manager a = src_mgr.Symbol("A") b = src_mgr.Symbol("B") f = src_mgr.And(a, src_mgr.Not(b)) self.assertEqual(str(f), "(A & (! B))", str(f)) serialized = pickle.dumps(f) f_new = pickle.loads(serialized) f_new = dst_mgr.normalize(f) args = f_new.args() self.assertEqual( str(args[0]), "A", "Expecting symbol A, " + "symbol %s found instead" % str(args[0])) a = dst_mgr.Symbol("A") b = dst_mgr.Symbol("B") g = dst_mgr.And(a, dst_mgr.Not(b)) # Contextualized formula is memoized self.assertEqual(f_new, g, "%s != %s" % (id(f_new), id(g))) # But it differs from the one in the other formula manager self.assertNotEqual(f_new, f) # Normalizing a formula in the same manager should not # be a problem f_new = src_mgr.normalize(f) self.assertEqual(f_new, f, "%s != %s" % (id(a), id(b))) def test_infix(self): x, y, p = self.x, self.y, self.p with self.assertRaises(Exception): x.Implies(y) get_env().enable_infix_notation = True self.assertEqual(Implies(x, y), x.Implies(y)) self.assertEqual(p + p, Plus(p, p)) self.assertEqual(p > p, GT(p, p)) get_env().enable_infix_notation = False def test_infix_extended(self): p, r, x, y = self.p, self.r, self.x, self.y get_env().enable_infix_notation = True self.assertEqual(Plus(p, Int(1)), p + 1) self.assertEqual(Plus(r, Real(1)), r + 1) self.assertEqual(Times(r, Real(1)), r * 1) self.assertEqual(Minus(p, Int(1)), p - 1) self.assertEqual(Minus(r, Real(1)), r - 1) self.assertEqual(Times(r, Real(1)), r * 1) self.assertEqual(Plus(r, Real(1.5)), r + 1.5) self.assertEqual(Minus(r, Real(1.5)), r - 1.5) self.assertEqual(Times(r, Real(1.5)), r * 1.5) self.assertEqual(Plus(r, Real(1.5)), 1.5 + r) self.assertEqual(Times(r, Real(1.5)), 1.5 * r) with self.assertRaises(TypeError): foo = p + 1.5 self.assertEqual(Not(x), ~x) self.assertEqual(Times(r, Real(-1)), -r) self.assertEqual(Times(p, Int(-1)), -p) self.assertEqual(Xor(x, y), x ^ y) self.assertEqual(And(x, y), x & y) self.assertEqual(Or(x, y), x | y) self.assertEqual(Or(x, TRUE()), x | True) self.assertEqual(Or(x, TRUE()), True | x) self.assertEqual(And(x, TRUE()), x & True) self.assertEqual(And(x, TRUE()), True & x) get_env().enable_infix_notation = False def test_toReal(self): f = self.mgr.Equals(self.rconst, self.mgr.ToReal(self.p)) self.assertIsNotNone(f) with self.assertRaises(TypeError): self.mgr.ToReal(self.x) f1 = self.mgr.ToReal(self.p) f2 = self.mgr.ToReal(f1) self.assertEqual(f1, f2) self.assertTrue(f1.is_toreal()) self.assertEqual(set([self.p]), f1.get_free_variables()) f3 = self.mgr.Equals(self.iconst, self.p) with self.assertRaises(TypeError): self.mgr.ToReal(f3) f4 = self.mgr.Plus(self.rconst, self.r) f5 = self.mgr.ToReal(f4) self.assertEqual(f5, f4) def test_equals_or_iff(self): eq_1 = self.mgr.EqualsOrIff(self.p, self.q) eq_2 = self.mgr.Equals(self.p, self.q) self.assertEqual(eq_1, eq_2) iff_1 = self.mgr.EqualsOrIff(self.x, self.y) iff_2 = self.mgr.Iff(self.x, self.y) self.assertEqual(iff_1, iff_2) def test_is_term(self): and_x_x = self.mgr.And(self.x, self.x) apply_f = self.mgr.Function(self.f, [self.r, self.s]) self.assertTrue(self.x.is_term()) self.assertTrue(and_x_x.is_term()) self.assertFalse(self.f.is_term()) self.assertTrue(apply_f.is_term()) def test_formula_in_formula_manager(self): x = self.mgr.FreshSymbol() and_x_x = self.mgr.And(x, x) new_mgr = FormulaManager(get_env()) y = new_mgr.FreshSymbol() and_y_y = new_mgr.And(y, y) self.assertTrue(x in self.mgr) self.assertFalse(y in self.mgr) self.assertTrue(and_x_x in self.mgr) self.assertFalse(and_y_y in self.mgr) def test_typing(self): self.assertTrue(BOOL.is_bool_type()) self.assertFalse(BOOL.is_function_type()) self.assertTrue(REAL.is_real_type()) self.assertFalse(REAL.is_bool_type()) self.assertTrue(INT.is_int_type()) self.assertFalse(INT.is_real_type()) self.assertTrue(self.ftype.is_function_type()) self.assertFalse(self.ftype.is_int_type())
class TestFormulaManager(TestCase): def setUp(self): super(TestFormulaManager, self).setUp() self.env = get_env() self.mgr = self.env.formula_manager self.x = self.mgr.Symbol("x") self.y = self.mgr.Symbol("y") self.p = self.mgr.Symbol("p", INT) self.q = self.mgr.Symbol("q", INT) self.r = self.mgr.Symbol("r", REAL) self.s = self.mgr.Symbol("s", REAL) self.rconst = self.mgr.Real(10) self.iconst = self.mgr.Int(10) self.ftype = FunctionType(REAL, [REAL, REAL]) self.f = self.mgr.Symbol("f", self.ftype) self.real_expr = self.mgr.Plus(self.s, self.r) def test_new_fresh_symbol(self): fv1 = self.mgr.new_fresh_symbol(BOOL) self.assertIsNotNone(fv1, "New symbol was not created.") fv2 = self.mgr.new_fresh_symbol(BOOL) self.assertNotEqual(fv1, fv2, "Fresh symbol is not new.") fv3 = self.mgr.new_fresh_symbol(BOOL, "abc_%d") self.assertEqual(fv3.symbol_name()[:3], "abc", "Fresh variable doesn't have the desired prefix") def test_get_symbol(self): with self.assertRaises(UndefinedSymbolError): a = self.mgr.get_symbol("a") self.mgr.get_or_create_symbol("a", BOOL) a = self.mgr.get_symbol("a") self.assertIsNotNone(a, "Symbol was not found in symbol table") def test_get_or_create_symbol(self): a = self.mgr.get_or_create_symbol("a", REAL) self.assertIsNotNone(a, "Symbol was not created") a2 = self.mgr.get_or_create_symbol("a", REAL) self.assertEqual(a, a2, "Symbol was not memoized") with self.assertRaises(TypeError): self.mgr.get_or_create_symbol("a", BOOL) def test_symbol(self): a1 = self.mgr.Symbol("a", BOOL) self.assertIsNotNone(a1, "Symbol was not created.") a2 = self.mgr.Symbol("a", BOOL) self.assertEqual(a1, a2, "Symbol is not memoized") c = self.mgr.Symbol("c") self.assertEqual(c.symbol_type(), BOOL, "Default Symbol Type is not BOOL") def test_and_node(self): n = self.mgr.And(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_and()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) m = self.mgr.And([self.x, self.y]) self.assertEqual(m, n, "And(1,2) != And([1,2]") args = m.args() self.assertTrue(self.x in args and self.y in args) self.assertTrue(len(args) == 2) zero = self.mgr.And() self.assertEqual(zero, self.mgr.TRUE()) one = self.mgr.And(self.x) self.assertEqual(one, self.x) def test_or_node(self): n = self.mgr.Or(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_or()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) m = self.mgr.Or([self.x, self.y]) self.assertEqual(m, n, "Or(1,2) != Or([1,2]") args = m.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 2) zero = self.mgr.Or() self.assertEqual(zero, self.mgr.FALSE()) one = self.mgr.Or(self.x) self.assertEqual(one, self.x) def test_not_node(self): n = self.mgr.Not(self.x) self.assertIsNotNone(n) self.assertTrue(n.is_not()) self.assertEqual(n.get_free_variables(), set([self.x])) args = n.args() self.assertIn(self.x, args) self.assertEqual(len(args), 1) self.assertEqual(self.mgr.Not(n), self.x) def test_implies_node(self): n = self.mgr.Implies(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_implies()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) args = n.args() self.assertEqual(self.x, args[0]) self.assertEqual(self.y, args[1]) self.assertEqual(len(args), 2) def test_iff_node(self): n = self.mgr.Iff(self.x, self.y) self.assertIsNotNone(n) self.assertTrue(n.is_iff()) self.assertEqual(n.get_free_variables(), set([self.x, self.y])) args = n.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 2) def test_ge_node_type(self): with self.assertRaises(TypeError): self.mgr.GE(self.x, self.r) with self.assertRaises(TypeError): self.mgr.GE(self.r, self.x) with self.assertRaises(TypeError): self.mgr.GE(self.p, self.r) def test_ge_node(self): n = self.mgr.GE(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.GE(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.GE(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.GE(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.GE(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.GE(self.p, self.q) self.assertIsNotNone(n) def test_minus_node(self): n = self.mgr.Minus(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.Minus(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Minus(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.Minus(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Minus(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Minus(self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_minus()) self.assertEqual(n.get_free_variables(), set([self.p, self.q])) with self.assertRaises(TypeError): n = self.mgr.Minus(self.r, self.q) def test_times_node(self): n = self.mgr.Times(self.real_expr, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Times(self.rconst, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.rconst, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Times(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_times()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) n = self.mgr.Times(self.iconst, self.q) self.assertIsNotNone(n) def test_div_node(self): n = self.mgr.Div(self.real_expr, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.Div(self.s, self.rconst) self.assertIsNotNone(n) inv = self.mgr.Real(Fraction(1) / self.rconst.constant_value()) self.assertEqual(n, self.mgr.Times(self.s, inv)) def test_equals(self): n = self.mgr.Equals(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.Equals(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.Equals(self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_equals()) self.assertEqual(n.get_free_variables(), set([self.p, self.q])) with self.assertRaises(TypeError): n = self.mgr.Equals(self.p, self.r) def test_gt_node_type(self): with self.assertRaises(TypeError): self.mgr.GT(self.x, self.r) with self.assertRaises(TypeError): self.mgr.GT(self.r, self.x) with self.assertRaises(TypeError): self.mgr.GT(self.r, self.p) def test_gt_node(self): n = self.mgr.GT(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.GT(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.GT(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.GT(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.GT(self.r, self.s) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) n = self.mgr.GT(self.p, self.q) self.assertIsNotNone(n) def test_le_node_type(self): with self.assertRaises(TypeError): self.mgr.LE(self.x, self.r) with self.assertRaises(TypeError): self.mgr.LE(self.r, self.x) def test_le_node(self): n = self.mgr.LE(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.LE(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.LE(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.LE(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.LE(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_le()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) def test_lt_node_type(self): with self.assertRaises(TypeError): self.mgr.LT(self.x, self.r) with self.assertRaises(TypeError): self.mgr.LT(self.r, self.x) def test_lt_node(self): n = self.mgr.LT(self.real_expr, self.real_expr) self.assertIsNotNone(n) n = self.mgr.LT(self.r, self.rconst) self.assertIsNotNone(n) n = self.mgr.LT(self.rconst, self.s) self.assertIsNotNone(n) n = self.mgr.LT(self.rconst, self.rconst) self.assertIsNotNone(n) n = self.mgr.LT(self.r, self.s) self.assertIsNotNone(n) self.assertTrue(n.is_lt()) self.assertEqual(n.get_free_variables(), set([self.r, self.s])) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) def test_ite(self): n = self.mgr.Ite(self.x, self.y, self.x) self.assertIsNotNone(n) args = n.args() self.assertIn(self.x, args) self.assertIn(self.y, args) self.assertEqual(len(args), 3) n = self.mgr.Ite(self.x, self.s, self.r) self.assertIsNotNone(n) n = self.mgr.Ite(self.x, self.p, self.q) self.assertIsNotNone(n) self.assertTrue(n.is_ite()) self.assertEqual(n.get_free_variables(), set([self.x, self.p, self.q])) with self.assertRaises(TypeError): self.mgr.Ite(self.x, self.p, self.r) def test_function(self): n = self.mgr.Function(self.f, [self.r, self.s]) self.assertIsNotNone(n) args = n.args() self.assertIn(self.r, args) self.assertIn(self.s, args) self.assertEqual(len(args), 2) self.assertTrue(n.is_function_application()) self.assertEqual(n.get_free_variables(), set([self.f, self.r, self.s])) def test_0arity_function(self): # Calling FunctionType on a 0-arity list of parameters returns # the type itself. t = FunctionType(REAL, []) # After this call: t = REAL # s1 is a symbol of type real s1 = self.mgr.Symbol("s1", t) s1b = self.mgr.Function(s1, []) self.assertEqual(s1, s1b) def test_constant(self): n1 = self.mgr.Real(Fraction(100, 10)) self.assertIsNotNone(n1) self.assertTrue(n1.is_constant()) self.assertTrue(n1.is_real_constant()) n2 = self.mgr.Real((100, 10)) self.assertEqual(n1, n2, "Generation of constant does not provide a consistent result.") n3 = self.mgr.Real(10) self.assertEqual(n1, n3, "Generation of constant does not provide a consistent result.") n4 = self.mgr.Real(10.0) self.assertEqual(n1, n4, "Generation of constant does not provide a consistent result.") nd = self.mgr.Real(Fraction(100,1)) self.assertNotEqual(nd, n1) with self.assertRaises(TypeError): self.mgr.Real(True) nd = self.mgr.Int(10) self.assertIsNotNone(nd) self.assertTrue(nd.is_constant()) self.assertTrue(nd.is_int_constant()) def test_bconstant(self): n = self.mgr.Bool(True) m = self.mgr.Bool(False) self.assertIsNotNone(n) self.assertIsNotNone(m) self.assertNotEqual(n, m) self.assertTrue(n.is_constant()) self.assertTrue(n.is_bool_constant()) with self.assertRaises(TypeError): self.mgr.Bool(42) def test_plus_node(self): with self.assertRaises(TypeError): self.mgr.Plus([self.x, self.r]) with self.assertRaises(TypeError): self.mgr.Plus([self.p, self.r]) with self.assertRaises(TypeError): self.mgr.Plus() n1 = self.mgr.Plus([self.r, self.s]) n2 = self.mgr.Plus(self.r, self.s) self.assertIsNotNone(n1) self.assertIsNotNone(n2) self.assertEqual(n1, n2, "Constructed Plus expression do not match") self.assertTrue(n1.is_plus()) self.assertEqual(set([self.r, self.s]), n1.get_free_variables()) one = self.mgr.Plus([self.p]) self.assertEqual(one, self.p) def test_exactly_one(self): symbols = [ self.mgr.Symbol("s%d"%i, BOOL) for i in range(5) ] c = self.mgr.ExactlyOne(symbols) self.assertTrue(len(c.args()) > 1) t = self.mgr.Bool(True) c = c.substitute({symbols[0]: t, symbols[1]: t}).simplify() self.assertEqual(c, self.mgr.Bool(False), "ExactlyOne should not allow 2 symbols to be True") s1 = self.mgr.Symbol("x") s2 = self.mgr.Symbol("x") f1 = self.mgr.ExactlyOne((s for s in [s1,s2])) f2 = self.mgr.ExactlyOne([s1,s2]) f3 = self.mgr.ExactlyOne(s1,s2) self.assertEqual(f1,f2) self.assertEqual(f2,f3) @skipIfNoSolverForLogic(QF_BOOL) def test_exactly_one_is_sat(self): symbols = [ self.mgr.Symbol("s%d"%i, BOOL) for i in range(5) ] c = self.mgr.ExactlyOne(symbols) all_zero = self.mgr.And([self.mgr.Iff(s, self.mgr.Bool(False)) for s in symbols]) test_zero = self.mgr.And(c, all_zero) self.assertFalse(is_sat(test_zero, logic=QF_BOOL), "ExactlyOne should not allow all symbols to be False") def test_at_most_one(self): symbols = [ self.mgr.Symbol("s%d"%i, BOOL) for i in range(5) ] c = self.mgr.AtMostOne(symbols) self.assertTrue(len(c.args()) > 1) t = self.mgr.Bool(True) c = c.substitute({symbols[0]: t, symbols[1]: t}).simplify() self.assertEqual(c, self.mgr.Bool(False), "AtMostOne should not allow two symbols to be True") def test_xor(self): xor1 = self.mgr.Xor(self.x, self.y) self.assertIsNotNone(xor1) with self.assertRaises(TypeError): self.mgr.Xor(self.p, self.q) xor_false = self.mgr.Xor(self.mgr.TRUE(), self.mgr.TRUE()).simplify() self.assertEqual(xor_false, self.mgr.FALSE(), "Xor should be False if both arguments are True") xor_true = self.mgr.Xor(self.mgr.TRUE(), self.mgr.FALSE()).simplify() self.assertEqual(xor_true, self.mgr.TRUE(), "Xor should be True if both arguments are False") def test_all_different(self): many = 5 symbols = [self.mgr.Symbol("s%d"%i, INT) for i in range(many) ] f = self.mgr.AllDifferent(symbols) one = self.mgr.Int(1) for i in xrange(many): for j in xrange(many): if i != j: c = f.substitute({symbols[i]: one, symbols[j]: one}).simplify() self.assertEqual(c, self.mgr.Bool(False), "AllDifferent should not allow 2 symbols "\ "to be 1") c = f.substitute(dict((symbols[i],self.mgr.Int(i)) for i in xrange(many))) self.assertEqual(c.simplify(), self.mgr.Bool(True), "AllDifferent should be tautological for a set " \ "of different values") def test_min(self): min1 = self.mgr.Min(self.p, Plus(self.q, self.mgr.Int(1))) self.assertIsNotNone(min1) with self.assertRaises(TypeError): self.mgr.Min(self.p, self.r) min_int = self.mgr.Min(self.mgr.Int(1), self.mgr.Int(2), self.mgr.Int(3)) self.assertEqual(min_int.simplify(), self.mgr.Int(1), "The minimum of 1, 2 and 3 should be 1") min_real = self.mgr.Min(self.mgr.Real(1), self.mgr.Real(2), self.mgr.Real(3)) self.assertEqual(min_real.simplify(), self.mgr.Real(1), "The minimum of 1.0, 2.0 and 3.0 should be 1.0") def test_max(self): max1 = self.mgr.Max(self.p, Plus(self.q, self.mgr.Int(1))) self.assertIsNotNone(max1) with self.assertRaises(TypeError): self.mgr.Max(self.p, self.r) max_int = self.mgr.Max(self.mgr.Int(1), self.mgr.Int(2), self.mgr.Int(3)) self.assertEqual(max_int.simplify(), self.mgr.Int(3), "The maximum of 1, 2 and 3 should be 3") max_real = self.mgr.Max(self.mgr.Real(1), self.mgr.Real(2), self.mgr.Real(3)) self.assertEqual(max_real.simplify(), self.mgr.Real(3), "The maximum of 1.0, 2.0 and 3.0 should be 3.0") def test_pickling(self): import pickle src_env = Environment() dst_env = Environment() src_mgr = src_env.formula_manager dst_mgr = dst_env.formula_manager a = src_mgr.Symbol("A") b = src_mgr.Symbol("B") f = src_mgr.And(a, src_mgr.Not(b)) self.assertEqual(str(f), "(A & (! B))", str(f)) # NOTE: We cannot use the textual format for pickle, because # we are using slots. We can, however, use more advanced # versions of pickle. Therefore, we specify here to use the # latest protocol. serialized = pickle.dumps(f, pickle.HIGHEST_PROTOCOL) f_new = pickle.loads(serialized) f_new = dst_mgr.normalize(f) args = f_new.args() self.assertEqual(str(args[0]), "A", "Expecting symbol A, " + "symbol %s found instead" % str(args[0])) a = dst_mgr.Symbol("A") b = dst_mgr.Symbol("B") g = dst_mgr.And(a, dst_mgr.Not(b)) # Contextualized formula is memoized self.assertEqual(f_new, g, "%s != %s" % (id(f_new), id(g))) # But it differs from the one in the other formula manager self.assertNotEqual(f_new, f) # Normalizing a formula in the same manager should not # be a problem f_new = src_mgr.normalize(f) self.assertEqual(f_new, f, "%s != %s" %(id(a),id(b))) def test_infix(self): x, y, p = self.x, self.y, self.p with self.assertRaises(Exception): x.Implies(y) get_env().enable_infix_notation = True self.assertEqual(Implies(x,y), x.Implies(y)) self.assertEqual(p + p, Plus(p,p)) self.assertEqual(p > p, GT(p,p)) get_env().enable_infix_notation = False def test_infix_extended(self): p, r, x, y = self.p, self.r, self.x, self.y get_env().enable_infix_notation = True self.assertEqual(Plus(p, Int(1)), p + 1) self.assertEqual(Plus(r, Real(1)), r + 1) self.assertEqual(Times(r, Real(1)), r * 1) self.assertEqual(Minus(p, Int(1)), p - 1) self.assertEqual(Minus(r, Real(1)), r - 1) self.assertEqual(Times(r, Real(1)), r * 1) self.assertEqual(Plus(r, Real(1.5)), r + 1.5) self.assertEqual(Minus(r, Real(1.5)), r - 1.5) self.assertEqual(Times(r, Real(1.5)), r * 1.5) self.assertEqual(Plus(r, Real(1.5)), 1.5 + r) self.assertEqual(Times(r, Real(1.5)), 1.5 * r) with self.assertRaises(TypeError): foo = p + 1.5 self.assertEqual(Not(x), ~x) self.assertEqual(Times(r, Real(-1)), -r) self.assertEqual(Times(p, Int(-1)), -p) self.assertEqual(Xor(x, y), x ^ y) self.assertEqual(And(x, y), x & y) self.assertEqual(Or(x, y), x | y) self.assertEqual(Or(x, TRUE()), x | True) self.assertEqual(Or(x, TRUE()), True | x) self.assertEqual(And(x, TRUE()), x & True) self.assertEqual(And(x, TRUE()), True & x) # BVs # BV_CONSTANT: We use directly python numbers # # Note: In this case, the width is implicit (yikes!) The # width of the constant is inferred by the use of a # symbol or operator that enforces a bit_width. # # This works in very simple cases. For complex # expressions it is advisable to create a shortcut for # the given BVType. const1 = 3 const2 = 0b011 const3 = 0x3 # Since these are python numbers, the following holds self.assertEqual(const1, const2) self.assertEqual(const1, const3) # However, we cannot use infix pySMT Equals, since const1 is a # python int!!! with self.assertRaises(AttributeError): const1.Equals(const2) # We use the usual syntax to build a constant with a fixed width const1_8 = self.mgr.BV(3, width=8) # In actual code, one can simply create a macro for this: _8bv = lambda v : self.mgr.BV(v, width=8) const1_8b = _8bv(3) self.assertEqual(const1_8, const1_8b) # Equals forces constants to have the width of the operand self.assertEqual(const1_8.Equals(const1), self.mgr.Equals(const1_8, const1_8b)) # Symbols bv8 = self.mgr.FreshSymbol(BV8) bv7 = self.mgr.FreshSymbol(BVType(7)) self.assertEqual(bv8.Equals(const1), bv8.Equals(const1_8)) # BV_AND, self.assertEqual(bv8 & const1, self.mgr.BVAnd(bv8, const1_8)) self.assertEqual(const1 & bv8, self.mgr.BVAnd(bv8, const1_8)) self.assertEqual(const1 & bv8, self.mgr.BVAnd(bv8, const1_8)) # BV_XOR, self.assertEqual(bv8 ^ const1, self.mgr.BVXor(bv8, const1_8)) self.assertEqual(const1 ^ bv8, self.mgr.BVXor(bv8, const1_8)) # BV_OR, self.assertEqual(bv8 | const1, self.mgr.BVOr(bv8, const1_8)) self.assertEqual(const1 | bv8, self.mgr.BVOr(bv8, const1_8)) # BV_ADD, self.assertEqual(bv8 + const1, self.mgr.BVAdd(bv8, const1_8)) self.assertEqual(const1 + bv8, self.mgr.BVAdd(bv8, const1_8)) # BV_SUB, self.assertEqual(bv8 - const1, self.mgr.BVSub(bv8, const1_8)) self.assertEqual(const1 - bv8, self.mgr.BVSub(const1_8, bv8)) # BV_MUL, self.assertEqual(bv8 * const1, self.mgr.BVMul(bv8, const1_8)) self.assertEqual(const1 * bv8, self.mgr.BVMul(bv8, const1_8)) # BV_NOT: # !!!WARNING!!! Cannot be applied to python constants!! # This results in a negative number with self.assertRaises(ValueError): _8bv(~const1) # For symbols and expressions this works as expected self.assertEqual(~bv8, self.mgr.BVNot(bv8)) # BV_NEG -- Cannot be applied to 'infix' constants self.assertEqual(-bv8, self.mgr.BVNeg(bv8)) # BV_EXTRACT -- Cannot be applied to 'infix' constants self.assertEqual(bv8[0:7], self.mgr.BVExtract(bv8, 0, 7)) self.assertEqual(bv8[:7], self.mgr.BVExtract(bv8, end=7)) self.assertEqual(bv8[0:], self.mgr.BVExtract(bv8, start=0)) self.assertEqual(bv8[7], self.mgr.BVExtract(bv8, start=7, end=7)) # BV_ULT, self.assertEqual(bv8 < const1, self.mgr.BVULT(bv8, const1_8)) # BV_ULE, self.assertEqual(bv8 <= const1, self.mgr.BVULE(bv8, const1_8)) # BV_UGT self.assertEqual(bv8 > const1, self.mgr.BVUGT(bv8, const1_8)) # BV_UGE self.assertEqual(bv8 >= const1, self.mgr.BVUGE(bv8, const1_8)) # BV_LSHL, self.assertEqual(bv8 << const1, self.mgr.BVLShl(bv8, const1_8)) # BV_LSHR, self.assertEqual(bv8 >> const1, self.mgr.BVLShr(bv8, const1_8)) # BV_UDIV, self.assertEqual(bv8 / const1, self.mgr.BVUDiv(bv8, const1_8)) # BV_UREM, self.assertEqual(bv8 % const1, self.mgr.BVURem(bv8, const1_8)) # The following operators use the infix syntax left.Operator.right # These includes all signed operators # BVSLT, self.assertEqual(self.mgr.BVSLT(bv8, const1_8), bv8.BVSLT(const1_8)) #BVSLE, self.assertEqual(self.mgr.BVSLE(bv8, const1_8), bv8.BVSLE(const1_8)) #BVComp self.assertEqual(self.mgr.BVComp(bv8, const1_8), bv8.BVComp(const1_8)) #BVSDiv self.assertEqual(self.mgr.BVSDiv(bv8, const1_8), bv8.BVSDiv(const1_8)) #BVSRem self.assertEqual(self.mgr.BVSRem(bv8, const1_8), bv8.BVSRem(const1_8)) #BVAShr self.assertEqual(self.mgr.BVAShr(bv8, const1_8), bv8.BVAShr(const1_8)) #BVNand self.assertEqual(self.mgr.BVNand(bv8, const1_8), bv8.BVNand(const1_8)) #BVNor self.assertEqual(self.mgr.BVNor(bv8, const1_8), bv8.BVNor(const1_8)) #BVXnor self.assertEqual(self.mgr.BVXnor(bv8, const1_8), bv8.BVXnor(const1_8)) #BVSGT self.assertEqual(self.mgr.BVSGT(bv8, const1_8), bv8.BVSGT(const1_8)) #BVSGE self.assertEqual(self.mgr.BVSGE(bv8, const1_8), bv8.BVSGE(const1_8)) #BVSMod self.assertEqual(self.mgr.BVSMod(bv8, const1_8), bv8.BVSMod(const1_8)) #BVRol, self.assertEqual(self.mgr.BVRol(bv8, steps=5), bv8.BVRol(5)) #BVRor, self.assertEqual(self.mgr.BVRor(bv8, steps=5), bv8.BVRor(5)) #BVZExt, self.assertEqual(self.mgr.BVZExt(bv8, increase=4), bv8.BVZExt(4)) #BVSExt, self.assertEqual(self.mgr.BVSExt(bv8, increase=4), bv8.BVSExt(4)) #BVRepeat, self.assertEqual(self.mgr.BVRepeat(bv8, count=5), bv8.BVRepeat(5)) # Reset Env get_env().enable_infix_notation = False def test_toReal(self): f = self.mgr.Equals(self.rconst, self.mgr.ToReal(self.p)) self.assertIsNotNone(f) with self.assertRaises(TypeError): self.mgr.ToReal(self.x) f1 = self.mgr.ToReal(self.p) f2 = self.mgr.ToReal(f1) self.assertEqual(f1, f2) self.assertTrue(f1.is_toreal()) self.assertEqual(set([self.p]), f1.get_free_variables()) f3 = self.mgr.Equals(self.iconst, self.p) with self.assertRaises(TypeError): self.mgr.ToReal(f3) f4 = self.mgr.Plus(self.rconst, self.r) f5 = self.mgr.ToReal(f4) self.assertEqual(f5, f4) def test_equals_or_iff(self): eq_1 = self.mgr.EqualsOrIff(self.p, self.q) eq_2 = self.mgr.Equals(self.p, self.q) self.assertEqual(eq_1, eq_2) iff_1 = self.mgr.EqualsOrIff(self.x, self.y) iff_2 = self.mgr.Iff(self.x, self.y) self.assertEqual(iff_1, iff_2) def test_is_term(self): and_x_x = self.mgr.And(self.x, self.x) apply_f = self.mgr.Function(self.f, [self.r, self.s]) self.assertTrue(self.x.is_term()) self.assertTrue(and_x_x.is_term()) self.assertFalse(self.f.is_term()) self.assertTrue(apply_f.is_term()) def test_formula_in_formula_manager(self): x = self.mgr.FreshSymbol() and_x_x = self.mgr.And(x, x) new_mgr = FormulaManager(get_env()) y = new_mgr.FreshSymbol() and_y_y = new_mgr.And(y, y) self.assertTrue(x in self.mgr) self.assertFalse(y in self.mgr) self.assertTrue(and_x_x in self.mgr) self.assertFalse(and_y_y in self.mgr) def test_typing(self): self.assertTrue(BOOL.is_bool_type()) self.assertFalse(BOOL.is_function_type()) self.assertTrue(REAL.is_real_type()) self.assertFalse(REAL.is_bool_type()) self.assertTrue(INT.is_int_type()) self.assertFalse(INT.is_real_type()) self.assertTrue(self.ftype.is_function_type()) self.assertFalse(self.ftype.is_int_type()) def test_array_value(self): a1 = self.mgr.Array(INT, self.mgr.Int(0)) a2 = self.mgr.Array(INT, self.mgr.Int(0), {self.mgr.Int(12) : self.mgr.Int(0)}) self.assertEquals(a1, a2)