def _check_wrong_argument_types_binary(self, operation):
self.assertRaises(TypeError, lambda: operation(3, 4))
self.assertRaises(TypeError, lambda: operation(Multiset(Set(Couplet(1, 2))), 3))
self.assertIs(operation(Atom(3), Atom(4)), Undef())
self.assertIs(operation(Multiset(Set(Couplet(1, 2))), Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Couplet(1, 2), Couplet(3, 4)))
RaiseOnUndef.reset()
def _check_wrong_argument_types_binary(self, operation):
self.assertRaises(AttributeError, lambda: operation(3, Set(Couplet(1, 2))))
self.assertRaises(AttributeError, lambda: operation(Set(Couplet(1, 2)), 4))
self.assertIs(operation(Set(Couplet(1, 2)), Atom(4)), Undef())
self.assertIs(operation(Atom(3), Set(Couplet(1, 2))), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Couplet(1, 2), Couplet(3, 4)))
RaiseOnUndef.reset()
def _check_wrong_argument_type_unary(self, operation):
self.assertRaises(AttributeError, lambda: operation(3))
self.assertIs(operation(Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Set('a', 'b')))
RaiseOnUndef.reset()
self.assertIs(operation(Undef()), Undef())
self.assertIs(operation(Undef(), _checked=False), Undef())
def _check_wrong_argument_type_unary(self, operation):
self.assertRaises(AttributeError, lambda: operation(3))
self.assertIs(operation(Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Set('a', 'b')))
RaiseOnUndef.reset()
self.assertIs(operation(Undef()), Undef())
self.assertIs(operation(Undef(), _checked=False), Undef())
def _check_wrong_argument_types_binary(self, operation):
"""Negative tests for set algebra binary operations."""
self.assertRaises(TypeError, lambda: operation(3, Multiset(Atom(3))))
self.assertIs(operation(Atom(3), Multiset(Atom(4))), Undef())
self.assertRaises(TypeError, lambda: operation(Multiset(Atom(3), 4)))
self.assertIs(operation(Multiset(Atom(3)), Atom(4)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Atom(3), Multiset(Atom(4))))
self.assertRaises(UndefException, lambda: operation(Multiset(Atom(3)), Atom(4)))
RaiseOnUndef.reset()
def test_raise_on_undef(self):
"""Test the static class RaiseOnUndef."""
self.assertRaises(AssertionError, lambda: RaiseOnUndef())
self.assertEqual(RaiseOnUndef.get_level(), 0)
RaiseOnUndef.set_level(2)
self.assertEqual(RaiseOnUndef.get_level(), 2)
RaiseOnUndef.set_level(4)
self.assertEqual(RaiseOnUndef.get_level(), 4)
RaiseOnUndef.reset()
self.assertEqual(RaiseOnUndef.get_level(), 0)
def test_transpose(self):
"""Basic tests of couplets.transpose()."""
# Wrong argument types.
self.assertRaises(TypeError, lambda: transpose(3))
self.assertIs(transpose(Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: transpose(Set('a', 'b')))
RaiseOnUndef.reset()
# T(a^b) = b^a
result = transpose(_couplet_a_to_b)
self.assertEqual(result, _couplet_b_to_a)
def _check_wrong_argument_types_unary(self, operation):
"""Negative tests for set algebra unary operations."""
self.assertIs(operation(Atom(3)), Undef())
self.assertIs(operation(Set(Atom(3))), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Atom(3)))
self.assertRaises(UndefException, lambda: operation(Multiset(Atom(3))))
RaiseOnUndef.reset()
self.assertIs(operation(Undef()), Undef())
self.assertIs(operation(Undef(), _checked=False), Undef())
def _check_wrong_argument_types_unary(self, operation):
"""Negative tests for set algebra unary operations."""
self.assertIs(operation(Atom(3)), Undef())
self.assertIs(operation(Set(Atom(3))), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Atom(3)))
self.assertRaises(UndefException, lambda: operation(Multiset(Atom(3))))
RaiseOnUndef.reset()
self.assertIs(operation(Undef()), Undef())
self.assertIs(operation(Undef(), _checked=False), Undef())
def test_compose(self):
"""Basic tests of couplets.compose()."""
# Wrong argument types.
self.assertRaises(TypeError, lambda: compose(3, Couplet(1, 2)))
self.assertRaises(TypeError, lambda: compose(Couplet(1, 2), 3))
self.assertIs(compose(Atom(3), Couplet(1, 2)), Undef())
self.assertIs(compose(Couplet(1, 2), Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: compose(Set('a', 'b'), Set('c', 'd')))
RaiseOnUndef.reset()
# a^b * b^c = a^c
result = compose(_couplet_a_to_b, _couplet_b_to_c)
self.assertEqual(result, _couplet_a_to_c)
# b^c * c^d = b^d
result = compose(_couplet_b_to_c, _couplet_c_to_d)
self.assertEqual(result, _couplet_b_to_d)
# a^b * c^d = Undef (b != c)
result = compose(_couplet_a_to_b, _couplet_c_to_d)
self.assertIs(result, Undef())
RaiseOnUndef.set_level(2)
self.assertRaises(UndefException, lambda: compose(_couplet_a_to_b, _couplet_c_to_d))
RaiseOnUndef.reset()
# b^c * a^b = Undef (not commutative)
result = compose(_couplet_b_to_c, _couplet_a_to_b)
self.assertIs(result, Undef())
def test_compose(self):
"""Basic tests of couplets.compose()."""
# Wrong argument types.
self.assertRaises(AttributeError, lambda: compose(3, Couplet(1, 2)))
self.assertRaises(AttributeError, lambda: compose(Couplet(1, 2), 3))
self.assertIs(compose(Atom(3), Couplet(1, 2)), Undef())
self.assertIs(compose(Couplet(1, 2), Atom(3)), Undef())
self.assertRaises(
AssertionError,
lambda: compose(Atom(3), Couplet(1, 2), _checked=False))
self.assertRaises(
AssertionError,
lambda: compose(Couplet(1, 2), Atom(3), _checked=False))
# Wrong argument type is will raise with error level 1, but not with the default of 0
self.assertIs(compose(Set('a', 'b'), Set('c', 'd')), Undef())
RaiseOnUndef.set_level(1)
# Repeat the same compose with new level...generates exception
self.assertRaises(UndefException,
lambda: compose(Set('a', 'b'), Set('c', 'd')))
# At raise level 1, Undef will not raise
self.assertIs(compose(Couplet(1, 2), Undef()), Undef())
RaiseOnUndef.set_level(2)
# Repeat the same compose with new level...generates exception
self.assertRaises(UndefException,
lambda: compose(Couplet(1, 2), Undef()))
RaiseOnUndef.reset()
result = compose(_couplet_b_to_a, _couplet_c_to_b)
self.assertEqual(result, _couplet_c_to_a)
result = compose(_couplet_c_to_b, _couplet_d_to_c)
self.assertEqual(result, _couplet_d_to_b)
result = compose(_couplet_b_to_a, _couplet_d_to_c)
self.assertIs(result, Undef())
result = compose(Undef(), _couplet_d_to_c)
self.assertIs(result, Undef())
result = compose(_couplet_b_to_a, Undef())
self.assertIs(result, Undef())
result = compose(Undef(), _couplet_d_to_c, _checked=False)
self.assertIs(result, Undef())
RaiseOnUndef.set_level(2)
self.assertRaises(UndefException,
lambda: compose(_couplet_b_to_a, _couplet_d_to_c))
RaiseOnUndef.reset()
result = compose(_couplet_c_to_b, _couplet_b_to_a)
self.assertIs(result, Undef())
def _check_wrong_argument_types_binary(self, operation):
self.assertRaises(AttributeError, lambda: operation(3, 4))
self.assertRaises(AttributeError, lambda: operation(Set(Set(Couplet(1, 2))), 3))
self.assertIs(operation(Atom(3), Atom(4)), Undef())
self.assertIs(operation(Set(Set(Couplet(1, 2))), Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Couplet(1, 2), Couplet(3, 4)))
RaiseOnUndef.reset()
c = ac['clan1']
self.assertIs(operation(c, Undef()), Undef())
self.assertIs(operation(c, Undef(), _checked=False), Undef())
self.assertIs(operation(Undef(), c), Undef())
self.assertIs(operation(Undef(), c, _checked=False), Undef())
def test_transpose(self):
"""Basic tests of couplets.transpose()."""
# Wrong argument types.
self.assertIs(transpose(Atom(3)), Undef())
self.assertIs(transpose(Undef()), Undef())
self.assertIs(transpose(Undef(), _checked=False), Undef())
self.assertRaises(AttributeError, lambda: transpose(3))
self.assertRaises(AssertionError, lambda: transpose(Atom(3), _checked=False))
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: transpose(Set("a", "b")))
RaiseOnUndef.reset()
result = transpose(_couplet_b_to_a)
self.assertEqual(result, _couplet_a_to_b)
def test_transpose(self):
"""Basic tests of couplets.transpose()."""
# Wrong argument types.
self.assertIs(transpose(Atom(3)), Undef())
self.assertIs(transpose(Undef()), Undef())
self.assertIs(transpose(Undef(), _checked=False), Undef())
self.assertRaises(AttributeError, lambda: transpose(3))
self.assertRaises(AssertionError, lambda: transpose(Atom(3), _checked=False))
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: transpose(Set('a', 'b')))
RaiseOnUndef.reset()
result = transpose(_couplet_b_to_a)
self.assertEqual(result, _couplet_a_to_b)
def _check_wrong_argument_types_binary(self, operation):
"""Negative tests for set algebra binary operations."""
self.assertRaises(AttributeError, lambda: operation(3, Set(Atom(3))))
self.assertIs(operation(Atom(3), Set(Atom(4))), Undef())
self.assertRaises(TypeError, lambda: operation(Set(Atom(3), 4)))
self.assertIs(operation(Set(Atom(3)), Atom(4)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Atom(3), Set(Atom(4))))
self.assertRaises(UndefException, lambda: operation(Set(Atom(3)), Atom(4)))
RaiseOnUndef.reset()
self.assertIs(operation(_set1, Undef()), Undef())
self.assertIs(operation(_set1, Undef(), _checked=False), Undef())
self.assertIs(operation(Undef(), _set1), Undef())
self.assertIs(operation(Undef(), _set1, _checked=False), Undef())
def _check_wrong_argument_types_binary(self, operation):
"""Negative tests for set algebra binary operations."""
self.assertRaises(AttributeError, lambda: operation(3, Set(Atom(3))))
self.assertIs(operation(Atom(3), Set(Atom(4))), Undef())
self.assertRaises(TypeError, lambda: operation(Set(Atom(3), 4)))
self.assertIs(operation(Set(Atom(3)), Atom(4)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Atom(3), Set(Atom(4))))
self.assertRaises(UndefException, lambda: operation(Set(Atom(3)), Atom(4)))
RaiseOnUndef.reset()
self.assertIs(operation(_set1, Undef()), Undef())
self.assertIs(operation(_set1, Undef(), _checked=False), Undef())
self.assertIs(operation(Undef(), _set1), Undef())
self.assertIs(operation(Undef(), _set1, _checked=False), Undef())
def _check_wrong_argument_types_binary(self, operation):
self.assertRaises(AttributeError, lambda: operation(3, 4))
self.assertRaises(AttributeError,
lambda: operation(Multiset(Set(Couplet(1, 2))), 3))
self.assertIs(operation(Atom(3), Atom(4)), Undef())
self.assertIs(operation(Multiset(Set(Couplet(1, 2))), Atom(3)),
Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException,
lambda: operation(Couplet(1, 2), Couplet(3, 4)))
RaiseOnUndef.reset()
c = ac['clan1']
self.assertIs(operation(c, Undef()), Undef())
self.assertIs(operation(c, Undef(), _checked=False), Undef())
self.assertIs(operation(Undef(), c), Undef())
self.assertIs(operation(Undef(), c, _checked=False), Undef())
def test_make_or_raise_undef(self):
"""Test make_or_raise_undef() together with RaiseOnUndef."""
try:
self.assertEqual(RaiseOnUndef.get_level(), 0)
self.assertIs(make_or_raise_undef(), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: make_or_raise_undef())
self.assertIs(make_or_raise_undef(2), Undef())
RaiseOnUndef.set_level(2)
self.assertRaises(UndefException, lambda: make_or_raise_undef(2))
RaiseOnUndef.reset()
self.assertIs(make_or_raise_undef(2), Undef())
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
def test_make_or_raise_undef(self):
"""Test make_or_raise_undef() together with RaiseOnUndef."""
try:
self.assertEqual(RaiseOnUndef.get_level(), 0)
self.assertIs(make_or_raise_undef(), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: make_or_raise_undef())
self.assertIs(make_or_raise_undef(2), Undef())
RaiseOnUndef.set_level(2)
self.assertRaises(UndefException, lambda: make_or_raise_undef(2))
RaiseOnUndef.reset()
self.assertIs(make_or_raise_undef(2), Undef())
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
def test_compose(self):
"""Basic tests of couplets.compose()."""
# Wrong argument types.
self.assertRaises(AttributeError, lambda: compose(3, Couplet(1, 2)))
self.assertRaises(AttributeError, lambda: compose(Couplet(1, 2), 3))
self.assertIs(compose(Atom(3), Couplet(1, 2)), Undef())
self.assertIs(compose(Couplet(1, 2), Atom(3)), Undef())
self.assertRaises(AssertionError, lambda: compose(Atom(3), Couplet(1, 2), _checked=False))
self.assertRaises(AssertionError, lambda: compose(Couplet(1, 2), Atom(3), _checked=False))
# Wrong argument type is will raise with error level 1, but not with the default of 0
self.assertIs(compose(Set("a", "b"), Set("c", "d")), Undef())
RaiseOnUndef.set_level(1)
# Repeat the same compose with new level...generates exception
self.assertRaises(UndefException, lambda: compose(Set("a", "b"), Set("c", "d")))
# At raise level 1, Undef will not raise
self.assertIs(compose(Couplet(1, 2), Undef()), Undef())
RaiseOnUndef.set_level(2)
# Repeat the same compose with new level...generates exception
self.assertRaises(UndefException, lambda: compose(Couplet(1, 2), Undef()))
RaiseOnUndef.reset()
result = compose(_couplet_b_to_a, _couplet_c_to_b)
self.assertEqual(result, _couplet_c_to_a)
result = compose(_couplet_c_to_b, _couplet_d_to_c)
self.assertEqual(result, _couplet_d_to_b)
result = compose(_couplet_b_to_a, _couplet_d_to_c)
self.assertIs(result, Undef())
result = compose(Undef(), _couplet_d_to_c)
self.assertIs(result, Undef())
result = compose(_couplet_b_to_a, Undef())
self.assertIs(result, Undef())
result = compose(Undef(), _couplet_d_to_c, _checked=False)
self.assertIs(result, Undef())
RaiseOnUndef.set_level(2)
self.assertRaises(UndefException, lambda: compose(_couplet_b_to_a, _couplet_d_to_c))
RaiseOnUndef.reset()
result = compose(_couplet_c_to_b, _couplet_b_to_a)
self.assertIs(result, Undef())
def _check_wrong_argument_type_unary(self, operation):
try:
self.assertRaises(AttributeError, lambda: operation(3))
self.assertIs(operation(Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Set('a', 'b')))
RaiseOnUndef.reset()
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
def _check_wrong_argument_types_unary(self, operation):
"""Negative tests for set algebra unary operations."""
try:
self.assertIs(operation(Atom(3)), Undef())
self.assertIs(operation(Set(Atom(3))), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Atom(3)))
self.assertRaises(UndefException, lambda: operation(Multiset(Atom(3))))
RaiseOnUndef.reset()
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
def _check_wrong_argument_types_binary(self, operation):
try:
self.assertRaises(AttributeError, lambda: operation(3, 4))
self.assertRaises(AttributeError, lambda: operation(Set(Set(Couplet(1, 2))), 3))
self.assertIs(operation(Atom(3), Atom(4)), Undef())
self.assertIs(operation(Set(Set(Couplet(1, 2))), Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Couplet(1, 2), Couplet(3, 4)))
RaiseOnUndef.reset()
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
def test_transpose(self):
"""Basic tests of couplets.transpose()."""
# Wrong argument types.
try:
self.assertRaises(AttributeError, lambda: transpose(3))
self.assertIs(transpose(Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: transpose(Set('a', 'b')))
RaiseOnUndef.reset()
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
result = transpose(_couplet_b_to_a)
self.assertEqual(result, _couplet_a_to_b)
def _check_wrong_argument_types_binary(self, operation):
"""Negative tests for set algebra binary operations."""
self.assertRaises(AttributeError, lambda: operation(3, Set(Atom(3))))
self.assertIs(operation(Atom(3), Set(Atom(4))), Undef())
self.assertRaises(TypeError, lambda: operation(Set(Atom(3), 4)))
self.assertIs(operation(Set(Atom(3)), Atom(4)), Undef())
try:
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: operation(Atom(3), Set(Atom(4))))
self.assertRaises(UndefException, lambda: operation(Set(Atom(3)), Atom(4)))
RaiseOnUndef.reset()
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
def test_raise_on_undef(self):
"""Test the static class RaiseOnUndef."""
self.assertRaises(AssertionError, lambda: RaiseOnUndef())
self.assertEqual(RaiseOnUndef.get_level(), 0)
RaiseOnUndef.set_level(2)
self.assertEqual(RaiseOnUndef.get_level(), 2)
RaiseOnUndef.set_level(4)
self.assertEqual(RaiseOnUndef.get_level(), 4)
RaiseOnUndef.reset()
self.assertEqual(RaiseOnUndef.get_level(), 0)
def test_compose(self):
"""Basic tests of couplets.compose()."""
# Wrong argument types.
try:
self.assertRaises(AttributeError, lambda: compose(3, Couplet(1, 2)))
self.assertRaises(AttributeError, lambda: compose(Couplet(1, 2), 3))
self.assertIs(compose(Atom(3), Couplet(1, 2)), Undef())
self.assertIs(compose(Couplet(1, 2), Atom(3)), Undef())
RaiseOnUndef.set_level(1)
self.assertRaises(UndefException, lambda: compose(Set('a', 'b'), Set('c', 'd')))
RaiseOnUndef.reset()
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
result = compose(_couplet_b_to_a, _couplet_c_to_b)
self.assertEqual(result, _couplet_c_to_a)
result = compose(_couplet_c_to_b, _couplet_d_to_c)
self.assertEqual(result, _couplet_d_to_b)
try:
result = compose(_couplet_b_to_a, _couplet_d_to_c)
self.assertIs(result, Undef())
RaiseOnUndef.set_level(2)
self.assertRaises(UndefException, lambda: compose(_couplet_b_to_a, _couplet_d_to_c))
RaiseOnUndef.reset()
except: # Make sure RaiseOnUndef level gets reset.
RaiseOnUndef.reset()
raise
result = compose(_couplet_c_to_b, _couplet_b_to_a)
self.assertIs(result, Undef())
