def test_order(self): x = boolean.Symbol(1) y = boolean.Symbol(2) self.assertTrue(x < ~x) self.assertTrue(~x > x) self.assertTrue(~x < y) self.assertTrue(y > ~x)
def test_literals(self): l1 = boolean.Symbol(1) l2 = boolean.Symbol(1) self.assertTrue(l1 in l1.literals) self.assertTrue(l1 in l2.literals) self.assertTrue(l2 in l1.literals) self.assertTrue(l2 in l2.literals) self.assertRaises(AttributeError, setattr, l1, "literals", 1)
def test_distributive(self): a = self.a b = self.b c = self.c d = boolean.Symbol("d") e = boolean.Symbol("e") self.assertTrue((a * (b + c)).distributive() == (a * b) + (a * c)) t1 = boolean.AND(a, (b + c), (d + e)) t2 = boolean.OR(boolean.AND(a, b, d), boolean.AND(a, b, e), boolean.AND(a, c, d), boolean.AND(a, c, e)) self.assertTrue(t1.distributive() == t2)
def test_class_order(self): order = ( (boolean.TRUE, boolean.FALSE), (boolean.Symbol(), boolean.Symbol("x")), (boolean.parse("x*y"), ), (boolean.parse("x+y"), ), ) for i, tests in enumerate(order): for case1 in tests: for j in range(i + 1, len(order)): for case2 in order[j]: self.assertTrue(case1 < case2) self.assertTrue(case2 > case1)
def test_printing(self): a = boolean.Symbol("a") self.assertTrue(str(~a) == "~a") self.assertTrue(repr(~a) == "NOT(Symbol('a'))") expr = boolean.parse("~(a*a)", eval=False) self.assertTrue(str(expr) == "~(a*a)") self.assertTrue(repr(expr) == "NOT(AND(Symbol('a'), Symbol('a')))")
def test_cancel(self): a = boolean.Symbol("a") parse = lambda x: boolean.parse(x, eval=False) self.assertTrue(~a == (~a).cancel()) self.assertTrue(a == parse("~~a").cancel()) self.assertTrue(~a == parse("~~~a").cancel()) self.assertTrue(a == parse("~~~~a").cancel())
def test_eval(self): a = boolean.Symbol("a") self.assertTrue(~a == ~a) self.assertFalse(a == boolean.parse("~~a", eval=False)) self.assertTrue(a == ~~a) self.assertTrue(~a, ~~~a) self.assertTrue(a, ~~~~a) self.assertTrue(~(a * a * a) == ~(a * a * a))
def test_literals(self): a = boolean.Symbol("a") l = ~a self.assertTrue(l.isliteral) self.assertTrue(l in l.literals) self.assertTrue(len(l.literals) == 1) l = boolean.parse("~(a*a)", eval=False) self.assertFalse(l.isliteral) self.assertTrue(a in l.literals) self.assertTrue(len(l.literals) == 1)
def test_equal(self): a = boolean.Symbol("a") b = boolean.Symbol("a") c = boolean.Symbol("b") d = boolean.Symbol() e = boolean.Symbol() # Test __eq__. self.assertTrue(a == a) self.assertTrue(a == b) self.assertFalse(a == c) self.assertFalse(b == c) self.assertTrue(d == d) self.assertFalse(d == e) self.assertFalse(a == d) # Test __ne__. self.assertFalse(a != a) self.assertFalse(a != b) self.assertTrue(a != c) self.assertTrue(b != c)
def test_init(self): boolean.Symbol(1) boolean.Symbol("a") boolean.Symbol(None) boolean.Symbol(sum) boolean.Symbol((1, 2, 3)) boolean.Symbol([1, 2]) self.assertRaises(TypeError, boolean.Symbol, 1, 2)
def test_literalize(self): s = boolean.Symbol(1) self.assertTrue(s.literalize() is s)
def test_isliteral(self): self.assertTrue(boolean.Symbol(1).isliteral is True)
def test_printing(self): self.assertTrue(str(boolean.Symbol("a")) == "a") self.assertTrue(str(boolean.Symbol(1)) == "1") self.assertTrue(repr(boolean.Symbol("a")), "Symbol('a')") self.assertTrue(repr(boolean.Symbol(1)) == "Symbol(1)")
def test_isliteral(self): s = boolean.Symbol(1) self.assertTrue(boolean.NOT(s).isliteral) self.assertFalse(boolean.parse("~(a+b)").isliteral)
def test_eval(self): s = boolean.Symbol(1) self.assertTrue(s.eval() is s)
def test_annihilator(self): a = boolean.Symbol("a") p = lambda x: boolean.parse(x, eval=False) self.assertTrue(p("a*a").annihilator is boolean.FALSE) self.assertTrue(p("a+a").annihilator is boolean.TRUE)
def _to_expr(l:LabelsMap) -> boolean.Expression: expr = boolean.TRUE for var, val in l.items(): s = boolean.Symbol(var) expr = (expr * s) if val else (expr * ~s) return expr