def test_multiset(self): self.print_string('test_multiset') msets = [ Multiset(None, None), Multiset(False, False), Multiset(2, 2, 1), Multiset(2.0, 2.0, 3), Multiset(complex('1+2j')), Multiset('2', '3', '2'), Multiset(bytes(2)), Multiset(range(-1, 5), range(-1, 5), range(1, 5)), Multiset( frozenset([ None, bool(2), int(2), float(2), complex('1+2j'), str(2), bytes(2), range(-1, 5), frozenset([None, None]), tuple((34, 35)), Atom(int(2)), Couplet(-1, -2), Set('x', 'y', 'z') ])), Multiset(tuple((34, 35))), Multiset(Atom('jkh'), Atom('jkh'), Atom('AA'), Atom('jkh')), Multiset(Couplet('a', 1), Couplet('B', 1), Couplet('a', 1)), ] self.verify_string_import_export(msets) self.verify_file_import_export(msets)
def test_diagonal(self): base_set = Set(Atom(1)) diag_rels = [relations.diag(*base_set), relations.diag(1)] for diag_rel in diag_rels: self.assertEqual(diag_rel.cardinality, 1) self.assertTrue(relations.is_member(diag_rel)) self.assertTrue(diag_rel.has_element(Couplet(1, 1))) base_set = Set(Atom(1), Atom('a')) diag_clan = clans.diag(1, 'a') self.assertEqual(diag_clan.cardinality, 1) diag_rels = [ relations.diag(*base_set), relations.diag(1, 'a'), sets.single(diag_clan) ] for diag_rel in diag_rels: self.assertEqual(diag_rel.cardinality, 2) self.assertTrue(relations.is_member(diag_rel)) self.assertTrue(diag_rel.has_element(Couplet(1, 1))) self.assertTrue(diag_rel.has_element(Couplet('a', 'a'))) arg1 = Set(1, 2, 3) arg2 = [v for v in Set(1, 2, 3)] result_diag = Set(Couplet(1, 1), Couplet(2, 2), Couplet(3, 3)) self.assertEqual(relations.diag(*arg1), result_diag) self.assertEqual(relations.diag(*arg2), result_diag)
def test_basic_multiset(self): m = Multiset(_collections.Counter({'a': 2, 'b': 1})) self.assertEqual(m.cardinality, 3) m_repr = repr(m) m_str = str(m) self.assertEqual(m_repr, "Multiset({Atom('a'): 2, Atom('b'): 1})") self.assertEqual(m_str, "['a':2, 'b':1]") self.assertEqual(m.get_multiplicity(Atom('a')), 2) self.assertEqual(m.get_multiplicity(Atom('b')), 1) m_struct = m.get_ground_set() self.assertEqual(m_struct, _atom_multiset_struct) single_m = Multiset(Set([1, 2, 3, 4]), direct_load=True) self.assertEqual(single_m.cardinality, 1) self.assertEqual( repr(single_m), "Multiset({Set(Atom(1), Atom(2), Atom(3), Atom(4)): 1})") self.assertEqual(str(single_m), "[{1, 2, 3, 4}:1]") empty_m = Multiset() self.assertEqual(empty_m.cardinality, 0) self.assertEqual(repr(empty_m), "Multiset({})") self.assertEqual(str(empty_m), "[]") for element in m: self.assertTrue(isinstance(element, Atom))
def test_couplet(self): self.print_string('test_couplet') elements = [ None, bool(2), int(2), float(2), complex('1+2j'), str(2), bytes(2), range(-1, 5), frozenset([None, bool(2), int(2), float(2), complex('1+2j'), str(2), bytes(2), range(-1, 5), frozenset([None, None]), tuple((34, 35)), Atom(int(2)), Couplet(-1, -2), Set('x', 'y', 'z') ]), frozenset([Couplet(0, 1), Couplet(2, 3)]), frozenset([Set('a', 'b', 'c'), Set([1, 2, 3])]), tuple((34, 35)), Atom(33), Couplet(0, 'abc'), Set(frozenset([None, 'xyz'])), ] couplets = [Couplet(s, c) for s in elements for c in elements] self.verify_string_import_export(couplets) self.verify_file_import_export(couplets)
def test_set(self): self.print_string('test_set') sets = [ Set(None), Set(False), Set(int(2)), Set(float(2)), Set(complex('1+2j')), Set(str(2)), Set(bytes(2)), Set(range(-1, 5)), Set( frozenset([ None, bool(2), int(2), float(2), complex('1+2j'), str(2), bytes(2), range(-1, 5), frozenset([None, None]), tuple((34, 35)), Atom(int(2)), Couplet(-1, -2), Set('x', 'y', 'z') ])), Set(tuple((34, 35))), Set(Atom('jkh')), Set(Couplet('a', '1')), ] self.verify_string_import_export(sets) self.verify_file_import_export(sets)
def test_membership(self): s = Set('a', 'b') self.assertTrue(Atom('a') in s) self.assertTrue('a' in s) self.assertTrue('b' in s) self.assertFalse('c' in s) self.assertTrue(s.has_element(Atom('a'))) self.assertFalse(s.has_element(Atom('c')))
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_defined_at(self): clan1 = Set(Set(Couplet('a', 1))) self.assertEqual(defined_at(clan1, 'a'), clan1) self.assertIs(defined_at(clan1, 'b'), Undef()) self.assertIs(defined_at(clan1, Undef()), Undef()) self.assertIs(defined_at(Undef(), 'a'), Undef()) self.assertRaises(AssertionError, lambda: defined_at(clan1, 'a', _checked=False)) self.assertIs(defined_at(Undef(), Atom('a'), _checked=False), Undef()) self.assertEqual(defined_at(clan1, Atom('a'), _checked=False), clan1)
def test_permutations(self): self.assertNotEqual(Atom(2), Atom(2.0)) self.assertTrue(Atom(2) != Atom(2.0)) self.assertFalse(Atom(2) == Atom(2.0)) values = [ None, bool(2), int(2), float(2), complex('1+2j'), str(2), bytes(2), range(-1, 5), frozenset([None, None]), tuple((34, 35)), Atom(int(2)), Couplet(-1, -2), Set('x', 'y', 'z') ] test = Atom(frozenset(values)) import itertools def top_n(n, generator): for _ in range(n): yield next(generator) # Test the first 100 permutations of values..frozenset sometimes orders differently # ..need to make sure that doesn't affect our equality check. for p in top_n(100, itertools.permutations(values)): act = Atom(frozenset(p)) if act != test: print("exp", test) print("act", act) self.assertEqual(test, act)
def test_defined_at(self): c1 = ac['clan1'] self.assertEqual(defined_at(c1, 'a'), c1) self.assertIs(defined_at(c1, 'd'), Undef()) self.assertIs(defined_at(c1, Undef()), Undef()) self.assertIs(defined_at(Undef(), 'a'), Undef()) self.assertRaises(AssertionError, lambda: defined_at(c1, 'a', _checked=False)) self.assertIs(defined_at(Undef(), Atom('a'), _checked=False), Undef()) self.assertEqual(defined_at(c1, Atom('a'), _checked=False), c1)
def test_getitem(self): self.assertEqual(Multiset()['callable'], Multiset()) # Creating multiclans (multisets of relations) multiset1 = Multiset({Couplet('b', 'w'): 2, Couplet('b', 'y'): 3}) multiset2 = Multiset({Couplet('a', 'x'): 5, Couplet('x', 'y'): 1}) right_values1 = multiset1[Atom('b')] self.assertEqual(right_values1, Multiset({Atom('w'): 2, Atom('y'): 3})) right_values2 = multiset2[Atom('b')] self.assertEqual(right_values2, Multiset())
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_equality(self): """Test equality concept of Atoms.""" for value_key1, atom1 in ba.items(): self._equality_assert(atom1, atom1) for value_key2, atom2 in ba.items(): if value_key1 == value_key2: self._equality_assert(atom1, atom2) else: self._inequality_assert(atom1, atom2) self.assertNotEqual(Atom(True), Atom(1)) self.assertNotEqual(Atom(True), 1) self.assertFalse(Atom(True) == 1)
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 test_equality(self): """Test equality concept of Atoms.""" for value_key1 in ['2', '2.0', "'2'"]: atom1 = ba[value_key1] self._equality_assert(atom1, atom1) for value_key2 in ['2', '2.0', "'2'"]: atom2 = ba[value_key2] if value_key1 == value_key2: self._equality_assert(atom1, atom2) else: self._inequality_assert(atom1, atom2) self.assertNotEqual(Atom(True), Atom(1)) self.assertNotEqual(Atom(True), 1) self.assertFalse(Atom(True) == 1)
def test_convert_identifier_to_mathobject(self): """Test the function _convert_identifier_to_mathobject().""" self.assertRaises(TypeError, lambda: _convert_identifier_to_mathobject(5)) self.assertEqual( Atom(URIRef('http://server/path')), _convert_identifier_to_mathobject(URIRef('http://server/path'))) self.assertEqual( Atom(BNode('http://server/path')), _convert_identifier_to_mathobject(BNode('http://server/path'))) self.assertNotEqual( Atom(BNode('http://server/path')), _convert_identifier_to_mathobject(URIRef('http://server/path'))) self.assertEqual( Atom(1), _convert_identifier_to_mathobject( Literal('1', datatype=XSD.integer))) self.assertEqual( Atom(1.0), _convert_identifier_to_mathobject(Literal('1', datatype=XSD.double))) self.assertNotEqual( Atom(1), _convert_identifier_to_mathobject(Literal('1', datatype=XSD.double))) self.assertEqual( Atom('1'), _convert_identifier_to_mathobject(Literal('1', datatype=XSD.string))) self.assertNotEqual( Atom(1), _convert_identifier_to_mathobject(Literal('1', datatype=XSD.string)))
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_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 test_membership(self): self.assertTrue(is_member(Set())) self.assertTrue(is_member(Set(3))) self.assertFalse(is_member(Atom(3))) self.assertTrue(is_absolute_member(Set(3))) self.assertFalse(is_absolute_member(Set(Couplet(3, 4)))) self.assertRaises(AttributeError, lambda: is_member(3))
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 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 _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_invalid_constructs(self): """Test invalid Atoms.""" self.assertRaises(TypeError, lambda: Atom(MathObject())) self.assertRaises(TypeError, lambda: Atom(Couplet(1, 2))) self.assertRaises(TypeError, lambda: Atom(Set())) self.assertRaises(TypeError, lambda: Atom(Undef())) self.assertRaises(TypeError, lambda: Atom([])) self.assertRaises(TypeError, lambda: Atom([7, '8'])) self.assertRaises(TypeError, lambda: Atom({})) self.assertRaises(TypeError, lambda: Atom({'one': 9, 2: 'ten'}))
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 _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_triple(self): """Test identifying a triple.""" # a relation with left set 'spo' and cardinality 3 triple = Set({Couplet('s', 1), Couplet('p', 2), Couplet('o', 3)}) self.assertTrue(is_triple(triple)) # a relation with left set 'abc' not_triple = Set({Couplet('a', 1), Couplet('b', 2), Couplet('c', 3)}) self.assertFalse(is_triple(not_triple)) # a relation with cardinality 4 not_triple = Set({ Couplet('s', 1), Couplet('p', 2), Couplet('o', 3), Couplet('a', 1) }) self.assertFalse(is_triple(not_triple)) # not a relation not_triple = Set({Atom('s'), Atom('p'), Atom('o')}) self.assertFalse(is_triple(not_triple))
def test_less_than(self): for value_key1, set1 in basic_sets.items(): for value_key2, set2 in basic_sets.items(): self.assertNotEqual(set1 < set2, NotImplemented) self.assertNotEqual(set2 < set1, NotImplemented) if set1 == set2: self.assertFalse(set1 < set2) self.assertFalse(set2 < set1) for mo in [Atom(1), Couplet(1, 2), Multiset(1, 2, 3)]: self.assertTrue(mo < set1)
def test_get_rights_for_left(self): """Basic tests of relations.get_rights_for_left().""" rel1 = Set(Couplet('a', 1), Couplet('a', 2), Couplet('b', 3)) result = Set(1, 2) self.assertEqual(result, get_rights_for_left(rel1, 'a')) self.assertEqual(Set(), get_rights_for_left(rel1, Undef())) self.assertEqual(Set(), get_rights_for_left(rel1, Undef(), _checked=False)) self.assertIs(get_rights_for_left(Undef(), 'a'), Undef()) self.assertRaises(AssertionError, lambda: get_rights_for_left(Undef(), 'a', _checked=False)) self.assertIs(get_rights_for_left(Undef(), Atom('a'), _checked=False), Undef())
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_right(self): """Basic tests of relations.get_right().""" self.assertRaises(AttributeError, lambda: get_right(3, 4)) self.assertIs(get_right(Atom(3), 4), Undef()) self.assertIs(get_right(Set(Couplet(1, 2), Couplet(1, 3)), Atom(1)), Undef()) self.assertIs(get_right(Set(Couplet(1, 2), Couplet(1, 3)), Atom(0)), Undef()) rel1 = ar['rel1'] self.assertIs(get_right(rel1, Undef()), Undef()) self.assertIs(get_right(rel1, Undef(), _checked=False), Undef()) self.assertIs(get_right(Undef(), 'a'), Undef()) self.assertRaises(AssertionError, lambda: get_right(Undef(), 'a', _checked=False)) self.assertIs(get_right(Undef(), Atom('a'), _checked=False), Undef()) for rel_idx in range(1, 3): rel_name = 'rel' + str(rel_idx) for couplet in ar[rel_name].data: left = couplet.left.value right = couplet.right.value result = get_right(ar[rel_name], left) self.assertEqual(result.value, right)
def test_flags_cache(self): a = Atom(1) self.assertEqual(a.cached_relation, CacheStatus.IS_NOT) self.assertEqual(a.cached_clan, CacheStatus.IS_NOT) self.assertEqual(a.cached_multiclan, CacheStatus.IS_NOT) self.assertEqual(a.cached_functional, CacheStatus.N_A) self.assertEqual(a.cached_right_functional, CacheStatus.N_A) self.assertEqual(a.cached_regular, CacheStatus.N_A) self.assertEqual(a.cached_reflexive, CacheStatus.N_A) self.assertEqual(a.cached_symmetric, CacheStatus.N_A) self.assertEqual(a.cached_transitive, CacheStatus.N_A) self.assertRaises(AssertionError, lambda: a.cache_relation(CacheStatus.IS)) self.assertRaises(AssertionError, lambda: a.cache_clan(CacheStatus.IS)) self.assertRaises(AssertionError, lambda: a.cache_multiclan(CacheStatus.IS)) self.assertRaises(Exception, lambda: a.cache_transitive(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: a.cache_functional(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: a.cache_right_functional(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: a.cache_regular(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: a.cache_reflexive(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: a.cache_symmetric(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: a.cache_transitive(CacheStatus.IS_NOT))