def test_diag(self): rel1 = Set(Couplet('a', 'a'), Couplet('b', 'b')) self.assertEqual(diag('a', 'b'), rel1) self.assertEqual(diag(), Set()) self.assertIs(diag(Undef()), Undef()) self.assertIs(diag(Undef(), _checked=False), Undef())
def test_project(self): """Basic tests of clans.project().""" self.assertIs(project(Undef(), Undef()), Undef()) c1 = ac['clan1'] self.assertIs(project(c1, Undef()), Undef()) c2 = Set(Set(Couplet('a', 1)), Set(Couplet('a', 4))) self.assertEqual(project(c1, 'a'), c2)
def _atom_assert(self, test_key): """Assert that 'test_atom' is a proper Atom (with test additions) with the value 'value'.""" atom = ba[test_key] value = atom._test_val value_val = value while type(value_val) == Atom: value_val = value_val.value msg = atom._test_msg # Test the type structure. self.assertTrue(isinstance(atom, MathObject)) self.assertTrue(isinstance(atom, Atom)) self.assertFalse(isinstance(atom, Couplet)) self.assertFalse(isinstance(atom, Set)) # Compare the value and make sure it is not a MathObject. atom_value = atom.value self.assertFalse(isinstance(atom_value, MathObject)) self.assertEqual(atom_value, value_val) # Make sure that the representations and string conversion of the atom and the value match. self.assertEqual(repr(atom), 'Atom({value})'.format(value=repr(value_val))) self.assertEqual(str(atom), repr(value_val)) # Make sure that the representation evaluates to an atom that compares equal. repr_exec = 'self.assertEqual(atom, {0})'.format(repr(atom)) exec(repr_exec) # Check the ground set. self.assertEqual(atom.get_ground_set(), GenesisSetA()) # Test left set and functionality. self.assertIs(atom.get_left_set(), Undef()) self.assertIs(is_functional(atom), Undef()) self.assertIs(atom('callable'), Undef()) # Print the representation and the string conversion. if self.print_examples: print('repr(Atom({msg})) = {repr}'.format(msg=msg, repr=repr(atom))) print('str(Atom({msg})) = {str}'.format(msg=msg, str=str(atom)))
def test_power_set(self): # self._check_argument_types_unary_undef(power_set) self.assertIs(power_set(Undef()), Undef()) s1 = Set(1, 2, 3) p1 = Set(Set(), Set(1), Set(2), Set(3), Set(1, 2), Set(1, 3), Set(2, 3), Set(1, 2, 3)) self.assertEqual(p1, power_set(s1))
def test_diag(self): """Basic tests of multiclans.diag().""" clan1 = Multiset(Set(Couplet('a'), Couplet('b'))) self.assertEqual(diag('a', 'b'), clan1) self.assertEqual(diag(), Multiset(Set())) self.assertIs(diag(Undef()), Undef()) self.assertIs(diag(Undef(), _checked=False), Undef())
def test_functional_add(self): rel1 = Set(Couplet('a', 1)) couplet = Couplet('b', 1) rel2 = Set(Couplet('a', 1), Couplet('b', 1)) self.assertEqual(functional_add(rel1, couplet), rel2) self.assertIs(functional_add(rel1, Undef()), Undef()) self.assertIs(functional_add(Undef(), couplet), Undef())
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 test_is_transitive(self): """Basic tests of relations.is_transitive().""" self.assertRaises(AttributeError, lambda: is_transitive(3)) self.assertIs(is_transitive(Atom(3)), Undef()) self.assertIs(is_transitive(Undef()), Undef()) self.assertIs(is_transitive(Undef(), _checked=False), Undef()) self.assertTrue(is_transitive(Set(Couplet('a', 'b'), Couplet('b', 'c'), Couplet('a', 'c')))) self.assertFalse(is_transitive(Set(Couplet('a', 'b'), Couplet('b', 'c'))))
def test_ne(self): """Test inequality.""" u1 = Undef() u2 = Undef() self.assertRaises(TypeError, lambda: u1 != u2) self.assertRaises(TypeError, lambda: u2 != u1) self.assertRaises(TypeError, lambda: u1 != u1) self.assertRaises(TypeError, lambda: u2 != u2) self.assertRaises(TypeError, lambda: u1 != 3)
def test_eq(self): """Test equality.""" u1 = Undef() u2 = Undef() self.assertRaises(TypeError, lambda: u1 == u2) self.assertRaises(TypeError, lambda: u2 == u1) self.assertRaises(TypeError, lambda: u1 == u1) self.assertRaises(TypeError, lambda: u2 == u2) self.assertRaises(TypeError, lambda: u1 == 'a')
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 test_is_right_functional(self): """Basic tests of relations.is_right_functional().""" self.assertRaises(AttributeError, lambda: is_right_functional(3)) self.assertIs(is_right_functional(Atom(3)), Undef()) self.assertIs(is_right_functional(Undef()), Undef()) self.assertIs(is_right_functional(Undef(), _checked=False), Undef()) for rel_idx in range(1, 3): rel_name = 'rel' + str(rel_idx) self.assertTrue(is_right_functional(ar[rel_name]))
def test_transpose(self): """Basic tests of relations.transpose().""" self._check_wrong_argument_type_unary(transpose) # Transpose. result = transpose(ar['rel1']) self.assertEqual(result, ar['rel1transp']) result = transpose(ar['reldiag']) self.assertEqual(result, ar['reldiag']) self.assertIs(transpose(Undef()), Undef()) self.assertIs(transpose(Undef(), _checked=False), Undef())
def test_restrict(self): self.assertIs(restrict(Undef(), Undef()), Undef()) s1 = Set(1, 2, 3) self.assertRaises(TypeError, lambda: restrict(s1, Undef())) self.assertRaises(TypeError, lambda: restrict(s1, 1)) self.assertRaises(TypeError, lambda: restrict(s1, 'a')) self.assertEqual(restrict(s1, lambda x: x.value < 3), Set(1, 2)) self.assertEqual(restrict(s1, lambda x: x.value > 1), Set(2, 3))
def test_singleton(self): """Test singleton characteristics.""" u1 = Undef() u2 = Undef() self.assertIs(u1, u2) self.assertIs(u1, Undef()) self.assertIs(u2, Undef()) self.assertTrue(u1 is Undef()) self.assertFalse( u1 is Undef, 'Undef refers to the class Undef, not the instance 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))) RaiseOnUndef.set_level(2) self.assertRaises(UndefException, lambda: operation(Set(Atom(3)))) RaiseOnUndef.reset() self._check_argument_types_unary_undef(operation)
def test_membership(self): self.assertTrue(is_member(Set(Couplet(1, 2)))) self.assertFalse(is_member(Couplet(3, 4))) self.assertFalse(is_member(Undef())) self.assertTrue(is_absolute_member(Set(Couplet(1, 2)))) self.assertFalse(is_absolute_member(Set(Couplet(Set(3), 4)))) self.assertFalse(is_absolute_member(Undef())) self.assertRaises(AttributeError, lambda: is_member(3)) s = Set(Couplet('field', Set(Couplet('name', 'Value'))), Couplet('field', Set(Couplet('name', 'Year'), Atom('1960')))) self.assertTrue(is_member(s))
def test_get_rights(self): """Basic tests of relations.get_rights().""" self._check_wrong_argument_type_unary(get_rights) # Right set. for rel_idx in range(1, 3): rel_name = 'rel' + str(rel_idx) rights_name = rel_name + '/rights' result = get_rights(ar[rel_name]) self.assertEqual(result, ar[rights_name]) self.assertIs(get_rights(Undef()), Undef()) self.assertIs(get_rights(Undef(), _checked=False), Undef())
def test_conversions(self): """test conversions""" u1 = Undef() u2 = Undef() self.assertRaises(TypeError, lambda: not u1) self.assertRaises(TypeError, lambda: u1 and u2) self.assertRaises(TypeError, lambda: u1 or u2) self.assertRaises(TypeError, lambda: bool(u1)) self.assertRaises(TypeError, lambda: int(u1)) self.assertRaises(TypeError, lambda: float(u1)) self.assertRaises( TypeError, lambda: {Undef()}) # Can't put Undef() in set()...not hashable
def test_regular(self): lefts = basic_sets['left func/lefts'] self.assertTrue(is_regular(Set())) self.assertIs(is_regular(lefts), Undef()) self.assertIs(is_regular(basic_sets['left func']), Undef()) self.assertTrue(is_regular(basic_clans['left func'])) self.assertFalse(is_regular(basic_clans['left func2'])) self.assertFalse(is_regular(basic_clans['not left func'])) embedded_has_irregular_left = Set(basic_sets['left func'], basic_sets['not left func']) self.assertFalse(is_regular(embedded_has_irregular_left)) s = basic_sets['left func'] self.assertEqual(s.cached_regular, CacheStatus.N_A)
def test_properties(self): a = ba['2'] self.assertIs(a.get_left_set(), Undef()) self.assertIs(is_functional(a), Undef()) self.assertIs(a.get_right_set(), Undef()) self.assertIs(is_right_functional(a), Undef()) self.assertIs(is_bijective(a), Undef()) self.assertIs(is_reflexive(a), Undef()) self.assertIs(is_symmetric(a), Undef()) self.assertIs(is_transitive(a), Undef()) self.assertIs(is_equivalence_relation(a), Undef())
def test_callable(self): # Undefined: self.assertIs(Set()('callable'), Undef()) for set_not_func in [basic_sets[name] for name in [ 'empty', 'num in dict', 'str in array', 'single num', 'left func/lefts', 'left func/rights', 'not left func']]: self.assertIs(set_not_func('callable'), Undef()) # Function: set1 = basic_sets['left func'] self.assertEqual(set1('a'), Atom(1)) self.assertEqual(set1('b'), Atom(2)) self.assertEqual(set1('c'), Atom(3)) set1 = basic_sets['diagonal'] for left in relations.get_lefts(set1): self.assertEqual(set1(left), left)
def add_atom(e1, e2): if type(e1) != Atom: return _make_or_raise_undef() if type(e2) != Atom: return _make_or_raise_undef() if not isinstance(e1.value, Number): return _make_or_raise_undef() if not isinstance(e2.value, Number): return _make_or_raise_undef() try: # noinspection PyUnresolvedReferences result = e1.value + e2.value except TypeError: result = Undef() return Atom(result) if result is not Undef() else result
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_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_equivalence_relation(self): self.assertTrue(is_equivalence_relation(Set())) self.assertFalse(is_equivalence_relation( Set([Couplet(s, c) for c, s in zip('aba', 'bcc')]))) self.assertIs(is_equivalence_relation(Set('a', 'b', 'c')), Undef()) self.assertFalse(is_equivalence_relation( Set([Couplet(s, c) for c, s in zip('aba', 'bcd')]))) f = is_equivalence_relation(basic_sets['left func']) self.assertFalse(f) f = is_equivalence_relation(basic_sets['not left func']) self.assertFalse(f) f = is_equivalence_relation(basic_sets['diagonal']) self.assertTrue(f) f = is_equivalence_relation(basic_clans['not left func']) self.assertFalse(f) f = is_equivalence_relation(basic_clans['diagonal']) self.assertTrue(f) f = is_equivalence_relation(basic_hordes['not left func']) self.assertFalse(f) f = is_equivalence_relation(basic_hordes['diagonal']) self.assertTrue(f) s = basic_sets['diagonal'] self.assertEqual(s.cached_reflexive, CacheStatus.IS) self.assertEqual(s.cached_symmetric, CacheStatus.IS) self.assertEqual(s.cached_transitive, CacheStatus.IS)
def test_transitive(self): self.assertTrue(is_transitive(Set())) self.assertTrue(is_transitive(Set())) self.assertTrue(is_transitive(Set([Couplet(s, c) for c, s in zip('aba', 'bcc')]))) self.assertIs(is_transitive(Set('a', 'b', 'c')), Undef()) rel = Set(Couplet(s, c) for c, s in zip('aba', 'bcd')) self.assertFalse(is_transitive(rel)) self.assertEqual(rel.cached_transitive, CacheStatus.IS_NOT) f = is_transitive(basic_sets['left func']) self.assertTrue(f) f = is_transitive(basic_sets['not left func']) self.assertTrue(f) f = is_transitive(basic_sets['diagonal']) self.assertTrue(f) f = is_transitive(basic_clans['not left func']) self.assertTrue(f) f = is_transitive(basic_clans['diagonal']) self.assertTrue(f) f = is_transitive(basic_hordes['not left func']) self.assertTrue(f) f = is_transitive(basic_hordes['diagonal']) self.assertTrue(f) s = basic_sets['left func'] self.assertEqual(s.cached_transitive, CacheStatus.IS)
def test_bijection(self): self.assertTrue(is_bijective(Set())) self.assertIs(is_bijective(Set('a', 'b', 'c')), Undef()) f = is_bijective(basic_sets['left func']) self.assertTrue(f) f = is_bijective(basic_sets['not left func']) self.assertFalse(f) f = is_bijective(basic_sets['not right func']) self.assertFalse(f) f = is_bijective(basic_clans['left func']) self.assertTrue(f) f = is_bijective(basic_clans['not right func']) self.assertFalse(f) f = is_bijective(basic_hordes['left func']) self.assertTrue(f) f = is_bijective(basic_hordes['not right func']) self.assertFalse(f) s = basic_sets['left func'] self.assertEqual(s.cached_functional, CacheStatus.IS) self.assertEqual(s.cached_right_functional, CacheStatus.IS) s = basic_sets['not left func'] self.assertEqual(s.cached_functional, CacheStatus.IS_NOT) # The right flags aren't checked if left fails self.assertEqual(s.cached_right_functional, CacheStatus.UNKNOWN)
def test_getitem(self): # Undefined: self.assertEqual(Set()['callable'], Set()) for set_not_func in [basic_sets[name] for name in [ 'num in dict', 'str in array', 'single num', 'left func/lefts', 'left func/rights']]: self.assertIs(set_not_func['callable'], Undef()) # Relation: set1 = basic_sets['left func'] self.assertEqual(set1['a'], Set(1)) self.assertEqual(set1['b'], Set(2)) self.assertEqual(set1['c'], Set(3)) set1 = basic_sets['not left func'] self.assertEqual(set1['a'], Set(1, 4)) self.assertEqual(set1['b'], Set(2)) self.assertEqual(set1['c'], Set(3)) set1 = basic_sets['diagonal'] for left in relations.get_lefts(set1): self.assertEqual(set1[left], Set(left)) # Clan of relations: self.assertEqual(algebra_clans['clan1']['a'], Set(1, 4)) self.assertEqual(algebra_clans['clan2']['x'], Set('a')) self.assertEqual(algebra_clans['clan2']['zzz'], Set('zzz')) self.assertEqual(algebra_clans['clan3']['c'], Set(3, 5)) self.assertEqual(algebra_clans['clan4'][3], Set('c')) self.assertEqual(algebra_clans['clan4'][5], Set('b', 'c')) self.assertEqual(algebra_clans['clan5']['b'], Set(2, 5)) self.assertEqual(algebra_clans['clan5']['c'], Set(3)) self.assertEqual(algebra_clans['clan5']['d'], Set())
def test_partition_multiset(self): test_set = OperationsTests.test_set2 even_part = partition.partition(test_set["input"], lambda elem: elem.left.value % 2 == 0) self.assertEqual(even_part, test_set["even_part"]) if OperationsTests._print_examples: print("Even partition (msets) Actual: ", even_part) print("Even partition (msets) Expected:", test_set["even_part"]) thirds_part = partition.partition(test_set["input2"], lambda elem: elem.left.value % 3) self.assertEqual(thirds_part, test_set["thirds_part"]) if OperationsTests._print_examples: print("Thirds partition (msets) Actual: ", thirds_part) print("Thirds partition (msets) Expected:", test_set["thirds_part"]) even_part_equiv = partition.make_labeled_partition( test_set["input"], lambda elem: elem.left.value % 2 == 0) self.assertEqual(even_part_equiv, test_set["even_part_equiv"]) if OperationsTests._print_examples: print(even_part_equiv) # Negative test, returning something that can not be put inside an atom my_equiv_rel_fun = lambda elem: "even" if elem.left.value % 2 == 0 else Undef( ) self.assertRaises( TypeError, lambda: partition.partition(test_set["input2"], my_equiv_rel_fun)) my_left_eq_rel_fn = lambda: partition.make_labeled_partition( test_set["input2"], my_equiv_rel_fun) self.assertRaises(TypeError, my_left_eq_rel_fn)