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))
