def test_simple_operations(self): result = union(_multiset1, _multiset2) self.assertEqual(result, Multiset(_collections.Counter("badog"))) result = add(_multiset1, _multiset2) self.assertEqual(result, _multiset3) result = intersect(_multiset1, _multiset2) self.assertEqual(result, Multiset(_collections.Counter("d"))) result = minus(_multiset_magic, _multiset1) self.assertEqual(result, Multiset(_collections.Counter("racaabra"))) p1 = Multiset(_collections.Counter("aaa")) p2 = Multiset(_collections.Counter("bbb")) p3 = Multiset(_collections.Counter("ccc")) combined = Set({p1, p2, p3}) result = big_union(combined) self.assertEqual(result, Multiset(_collections.Counter("abc" * 3))) result = big_intersect( Set({ _multiset_magic, Multiset(_collections.Counter("abc" * 3)), Multiset("a", "a", "b", "c") })) self.assertEqual(result, Multiset(_collections.Counter("aabc")))
def test_membership(self): self.assertTrue(is_member(Multiset())) self.assertTrue(is_member(Multiset(3))) self.assertFalse(is_member(Atom(3))) self.assertTrue(is_absolute_member(Multiset(3))) self.assertFalse(is_absolute_member(Multiset(Couplet(3, 4)))) self.assertRaises(AttributeError, lambda: is_member(3))
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_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_membership(self): self.assertTrue(is_member(Multiset(Set(Couplet(1, 2))))) self.assertFalse(is_member(Multiset(Couplet(3, 4)))) self.assertTrue(is_absolute_member(Multiset(Set(Couplet(1, 2))))) self.assertFalse( is_absolute_member(Multiset(Set(Couplet(Set(2, 3), 4))))) self.assertFalse(is_absolute_member(Set(2, 3))) # noinspection PyTypeChecker self.assertRaises(AttributeError, lambda: is_member(3))
def test_multify(self): self._check_argument_types_unary_undef(multify) letters = [l for l in "abracadabra"] self.assertIs(multify(Multiset(letters)), Undef()) multiset = multify(Set(letters)) # Set object drops duplicates self.assertTrue(isinstance(multiset, Multiset)) self.assertEqual(multiset.cardinality, 5) # multiset of unique items letters = [l for l in "abrcd"] self.assertEqual(multiset, Multiset(letters))
def test_binary_multi_extend_errors(self): self.assertRaises( AttributeError, lambda: extension.binary_multi_extend(1, 2, sets.union)) self.assertRaises( AttributeError, lambda: extension.binary_multi_extend(Multiset(1), 2, sets.union)) self.assertRaises( AttributeError, lambda: extension.binary_multi_extend(1, Multiset(2), sets.union))
def test_intersect(self): self._check_wrong_argument_types_binary(intersect) result = intersect(_set1, _set2) self.assertEqual(result, _set1i2) a_c_0 = Multiset( [Multiset('a'), Multiset('a'), Multiset('c'), Multiset()]) ci = extension.binary_multi_extend(_ab_c, _ac_a, intersect) self.assertEqual(ci, a_c_0)
def test_membership(self): s = Multiset({"a": 2, "b": 1}) 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"))) test_list = [Atom("a"), Atom("a"), Atom("b")] multiset_iter = iter(s) for i in range(len(test_list)): self.assertEqual(test_list[i], next(multiset_iter))
def test_membership(self): s = Multiset({'a': 2, 'b': 1}) 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'))) test_list = [Atom('a'), Atom('a'), Atom('b')] multiset_iter = iter(s) for i in range(len(test_list)): self.assertEqual(test_list[i], next(multiset_iter))
def test_membership(self): s = Multiset({'a': 2, 'b': 1}) 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'))) test_list = [Atom('a'), Atom('a'), Atom('b')] multiset_iter = iter(s) for i in multiset_iter: self.assertTrue(i in test_list) test_list.remove(i)
def test_union(self): self._check_wrong_argument_types_binary(union) result = union(_set1, _set2) self.assertEqual(result, _set1u2) abc_ab_ac = Multiset([ Multiset('a', 'b', 'c'), Multiset('a', 'b'), Multiset('a', 'c'), Multiset('a', 'c') ]) ab_c = _ab_c ac_a = _ac_a cu = extension.binary_multi_extend(ab_c, ac_a, union) self.assertEqual(cu, abc_ab_ac)
def test_project(self): """Basic tests of multiclans.project().""" self.assertIs(project(Undef(), Undef()), Undef()) c1 = ac['clan1'] self.assertIs(project(c1, Undef()), Undef()) c2 = Multiset(Set(Couplet('a', 1)), Set(Couplet('a', 4))) self.assertEqual(project(c1, 'a'), c2)
def test_superstrict(self): """Basic tests of clans.superstrict().""" self._check_wrong_argument_types_binary(superstrict) # Superstriction. result = superstrict(ac['clan1'], ac['clan2']) self.assertEqual(result, Multiset()) result = superstrict(ac['clan1'], ac['clan3']) self.assertEqual(result, ac['clan1subsupstr3'])
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_demultify(self): letters = [l for l in "abracadabra"] self.assertIs(demultify(Set(letters)), Undef()) set1 = demultify(Multiset(letters)) self.assertTrue(isinstance(set1, Set)) self.assertEqual(set1.cardinality, 5) # set only unique letters letters = [l for l in "abrcd"] self.assertEqual(set1, Set(letters))
def test_multiset_with_one_empty_element(self): m = Multiset(Set()) self.assertEqual(m.cardinality, 1) m_repr = repr(m) m_str = str(m) self.assertEqual(m_repr, "Multiset({Set(): 1})") self.assertEqual(m_str, "[{}:1]") self.assertEqual(m.get_multiplicity(Set()), 1) self.assertEqual(m.get_multiplicity(Atom('b')), 0) m_struct = m.get_ground_set() m_expected_struct = PowerSet(CartesianProduct(Structure(), GenesisSetN())) self.assertEqual(m_struct, m_expected_struct) import algebraixlib.algebras.multiclans as _multiclans self.assertTrue(_multiclans.is_member(m)) self.assertTrue(_multiclans.is_absolute_member(m))
def test_multiset_with_one_empty_element(self): m = Multiset(Set()) self.assertEqual(m.cardinality, 1) m_repr = repr(m) m_str = str(m) self.assertEqual(m_repr, "Multiset({Set(): 1})") self.assertEqual(m_str, "[{}:1]") self.assertEqual(m.get_multiplicity(Set()), 1) self.assertEqual(m.get_multiplicity(Atom('b')), 0) m_struct = m.get_ground_set() m_expected_struct = PowerSet( CartesianProduct(Structure(), GenesisSetN())) self.assertEqual(m_struct, m_expected_struct) import algebraixlib.algebras.multiclans as _multiclans self.assertTrue(_multiclans.is_member(m)) self.assertTrue(_multiclans.is_absolute_member(m))
def test_less_than(self): for value_key1, atom1 in ba.items(): for value_key2, atom2 in ba.items(): self.assertNotEqual(atom1 < atom2, NotImplemented) self.assertNotEqual(atom2 < atom1, NotImplemented) if atom1 == atom2: self.assertFalse(atom1 < atom2) self.assertFalse(atom2 < atom1) for mo in [Couplet(1, 2), Multiset(1, 2, 3), Set(1, 2, 3)]: self.assertTrue(atom1 < mo)
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 _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_less_than(self): for value_key1, cp1 in basic_couplets.items(): for value_key2, cp2 in basic_couplets.items(): self.assertNotEqual(cp1 < cp2, NotImplemented) self.assertNotEqual(cp2 < cp1, NotImplemented) if cp1 == cp2: self.assertFalse(cp1 < cp2) self.assertFalse(cp2 < cp1) for mo in [Atom(1)]: self.assertTrue(mo < cp1) for mo in [Multiset(1, 2, 3), Set(1, 2, 3)]: self.assertTrue(cp1 < mo)
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_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_binary(self, operation): """Negative tests for set algebra binary operations.""" self.assertRaises(AttributeError, 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() 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())
'empty': [], 'num in dict': {Atom(1), Atom(2), Atom(3)}, 'str in array': [Atom(el) for el in 'abc'], 'single num': 1, 'single Coupl': Couplet(right='a', left='b'), 'left func': [Couplet(l, r) for l, r in zip('abc', [1, 2, 3])], 'left func/lefts': ['a', 'b', 'c'], 'left func/rights': [1, 2, 3], 'not left func': [Couplet(s, c) for s, c in zip('abca', [1, 2, 3, 4])], 'not right func': [Couplet(s, c) for s, c in zip('abcd', [1, 2, 3, 1])], 'diagonal': [Couplet(s, s) for s in 'abc'] }.items()} _print_object_collection('basic_sets') #: Basic Multiset instances. basic_multisets = {key: _create_test_object(Multiset(val), key, val) for key, val in { 'empty': [], 'dict': dict([('a', 3), ('b', 2), ('c', 5)]), 'num in dict': {Atom(1), Atom(2), Atom(3)}, 'str in array': [Atom(el) for el in 'abc'], 'single alpha': 'A' }.items()} _print_object_collection('basic_multisets') #: Relation instances for testing the relation algebra. algebra_relations = {key: _create_test_object(val, key) for key, val in { 'rel1': Set([Couplet('a', 1), Couplet('b', 2), Couplet('c', 3)]), 'rel1/lefts': Set('a', 'b', 'c'), 'rel1/rights': Set([1, 2, 3]), 'rel2': Set([Couplet('x', 'a'), Couplet('zzz', 'zzz'), Couplet('y', 'c')]), 'rel2/lefts': Set(['x', 'zzz', 'y']),
class OperationsTests(unittest.TestCase): _print_examples = False 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) test_set1 = { "input": Set([ Couplet(1, '1'), Couplet(2, '2'), Couplet(3, '3'), Couplet(4, '4'), Couplet(5, '5') ]), "even_part": Set([ Set([Couplet(2, '2'), Couplet(4, '4')]), Set([Couplet(1, '1'), Couplet(3, '3'), Couplet(5, '5')]) ]), "even_part_equiv": Set([ Couplet(Atom(True), Set([Couplet(2, '2'), Couplet(4, '4')])), Couplet(Atom(False), Set([Couplet(1, '1'), Couplet(3, '3'), Couplet(5, '5')])) ]), "input2": Set([ Couplet(1, '1'), Couplet(2, '2'), Couplet(3, '3'), Couplet(4, '4'), Couplet(5, '5'), Couplet(6, '6'), Couplet(7, '7'), Couplet(8, '8'), Couplet(9, '9'), Couplet(10, '10'), Couplet(11, '11'), Couplet(12, '12'), Couplet(13, '13'), Couplet(14, '14'), Couplet(15, '15') ]), "thirds_part": Set([ Set([ Couplet(1, '1'), Couplet(4, '4'), Couplet(7, '7'), Couplet(10, '10'), Couplet(13, '13') ]), Set([ Couplet(2, '2'), Couplet(5, '5'), Couplet(8, '8'), Couplet(11, '11'), Couplet(14, '14') ]), Set([ Couplet(3, '3'), Couplet(6, '6'), Couplet(9, '9'), Couplet(12, '12'), Couplet(15, '15') ]) ]) } def test_partition(self): test_set = OperationsTests.test_set1 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 Actual: ", even_part) print("Even partition 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 Actual: ", thirds_part) print("Thirds partition 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) test_set2 = { "input": Multiset( Counter({ Couplet(1, '1'): 1, Couplet(2, '2'): 2, Couplet(3, '3'): 3, Couplet(4, '4'): 4, Couplet(5, '5'): 5 })), "even_part": Set([ Multiset(Counter({ Couplet(2, '2'): 2, Couplet(4, '4'): 4 })), Multiset( Counter({ Couplet(1, '1'): 1, Couplet(3, '3'): 3, Couplet(5, '5'): 5 })) ]), "even_part_equiv": Set([ Couplet( Atom(True), Multiset(Counter({ Couplet(2, '2'): 2, Couplet(4, '4'): 4 }))), Couplet( Atom(False), Multiset( Counter({ Couplet(1, '1'): 1, Couplet(3, '3'): 3, Couplet(5, '5'): 5 }))) ]), "input2": Multiset( Counter({ Couplet(1, '1'): 1, Couplet(2, '2'): 2, Couplet(3, '3'): 3, Couplet(4, '4'): 4, Couplet(5, '5'): 5, Couplet(6, '6'): 6, Couplet(7, '7'): 7, Couplet(8, '8'): 8, Couplet(9, '9'): 9, Couplet(10, '10'): 10, Couplet(11, '11'): 11, Couplet(12, '12'): 12, Couplet(13, '13'): 13, Couplet(14, '14'): 14, Couplet(15, '15'): 15 })), "thirds_part": Set([ Multiset( Counter({ Couplet(1, '1'): 1, Couplet(4, '4'): 4, Couplet(7, '7'): 7, Couplet(10, '10'): 10, Couplet(13, '13'): 13 })), Multiset( Counter({ Couplet(2, '2'): 2, Couplet(5, '5'): 5, Couplet(8, '8'): 8, Couplet(11, '11'): 11, Couplet(14, '14'): 14 })), Multiset( Counter({ Couplet(3, '3'): 3, Couplet(6, '6'): 6, Couplet(9, '9'): 9, Couplet(12, '12'): 12, Couplet(15, '15'): 15 })) ]) } 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) def test_unary_extend(self): """Verify that unary extend uses the input set and operation to invoke the equivalent operation in next higher power set.""" self.assertEqual(Set(Set(Couplet(1, 1))), extension.unary_extend(Set(*Set(1)), relations.diag)) def test_unary_extend_errors(self): self.assertRaises(AttributeError, lambda: extension.unary_extend(1, sets.big_union)) def test_binary_extend_errors(self): self.assertRaises(AttributeError, lambda: extension.binary_extend(1, 2, sets.union)) self.assertRaises( AttributeError, lambda: extension.binary_extend(Set(1), 2, sets.union)) self.assertRaises( AttributeError, lambda: extension.binary_extend(1, Set(2), sets.union)) def test_binary_multi_extend_errors(self): self.assertRaises( AttributeError, lambda: extension.binary_multi_extend(1, 2, sets.union)) self.assertRaises( AttributeError, lambda: extension.binary_multi_extend(Multiset(1), 2, sets.union)) self.assertRaises( AttributeError, lambda: extension.binary_multi_extend(1, Multiset(2), sets.union))
def test_some(self): # self._check_wrong_argument_types_unary(some) self.assertIs(some(Undef()), Undef()) self.assertIs(some(Multiset()), Undef()) self.assertEqual(some(_set1m2), Atom('a')) self.assertTrue(some(_set1) in _set1)
def test_flags_empty_set(self): s = Multiset() self.assertEqual(s.cached_relation, CacheStatus.IS_NOT) self.assertEqual(s.cached_clan, CacheStatus.IS_NOT) self.assertEqual(s.cached_multiclan, CacheStatus.IS) self.assertEqual(s.cached_functional, CacheStatus.IS) self.assertEqual(s.cached_right_functional, CacheStatus.IS) self.assertEqual(s.cached_regular, CacheStatus.IS) self.assertEqual(s.cached_reflexive, CacheStatus.IS) self.assertEqual(s.cached_symmetric, CacheStatus.IS) self.assertEqual(s.cached_transitive, CacheStatus.IS) self.assertRaises(AssertionError, lambda: s.cache_relation(CacheStatus.IS)) self.assertRaises(AssertionError, lambda: s.cache_clan(CacheStatus.IS)) self.assertRaises(AssertionError, lambda: s.cache_multiclan(CacheStatus.IS_NOT)) s.cache_multiclan(CacheStatus.IS) self.assertRaises(Exception, lambda: s.cache_transitive(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: s.cache_functional(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: s.cache_right_functional(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: s.cache_regular(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: s.cache_reflexive(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: s.cache_symmetric(CacheStatus.IS_NOT)) self.assertRaises(Exception, lambda: s.cache_transitive(CacheStatus.IS_NOT))
def test_invalid_constructs(self): """Test invalid Multisets.""" self.assertRaises(TypeError, lambda: Multiset(Undef()))
def test_from_dict(self): """Basic tests of multiclans.from_dict().""" c1 = Multiset(Set(Couplet('a', 1), Couplet('b', 2))) self.assertEqual(c1, from_dict({'a': 1, 'b': 2})) self.assertRaises(AttributeError, lambda: from_dict(Undef()))
def test_get_rights(self): """Basic tests of clans.get_rights().""" self._check_wrong_argument_type_unary(get_rights) self.assertEqual(get_rights(Multiset()), Multiset())
def test_csv(self): """Test loading clan from csv.""" clan = Set({Set({Couplet('a', '1'), Couplet('b', '2')})}) st1 = import_csv(IoCsvTests.path('set1.csv')) self.assertEqual(clan, st1) self.assertEqual(st1.cached_clan, CacheStatus.IS) self.assertEqual(st1.cached_functional, CacheStatus.IS) self.assertEqual(st1.cached_regular, CacheStatus.IS) clan = Set({Set({Couplet('a', '1'), Couplet('b', '2')})}) st1a = import_csv(IoCsvTests.path('set1a.csv')) # NOTE: duplicate row is removed self.assertEqual(clan, st1a) self.assertEqual(st1a.cached_clan, CacheStatus.IS) self.assertEqual(st1a.cached_functional, CacheStatus.IS) self.assertEqual(st1a.cached_regular, CacheStatus.IS) clan = Set( Set({Couplet('a', '1'), Couplet('b', '2'), Couplet('row', 0)}), Set({Couplet('a', '1'), Couplet('b', '2'), Couplet('row', 1)})) st1a = import_csv(IoCsvTests.path('set1a.csv'), index_column='row') # NOTE: duplicate row is NOT removed self.assertEqual(clan, st1a) self.assertEqual(st1a.cached_clan, CacheStatus.IS) self.assertEqual(st1a.cached_functional, CacheStatus.IS) self.assertEqual(st1a.cached_regular, CacheStatus.IS) expected = Multiset({Set(Couplet('a', '1'), Couplet('b', '2')): 2}) actual = import_csv(IoCsvTests.path('set1a.csv'), has_dup_rows=True) # NOTE: duplicate row is not removed self.assertEqual(actual, expected) self.assertEqual(actual.cached_multiclan, CacheStatus.IS) self.assertEqual(actual.cached_functional, CacheStatus.IS) self.assertEqual(actual.cached_regular, CacheStatus.IS) clan = Set({ Set({Couplet('a', '1'), Couplet('b', '2')}), Set({Couplet('a', '3'), Couplet('b', '4')}) }) st2 = import_csv(IoCsvTests.path('set2.csv')) self.assertEqual(clan, st2) self.assertEqual(st2.cached_clan, CacheStatus.IS) self.assertEqual(st2.cached_functional, CacheStatus.IS) self.assertEqual(st2.cached_regular, CacheStatus.IS) clan = Set(Set([Couplet(s, c) for s, c in zip('abcd', [1, 2, 3, 4])]), Set([Couplet(s, c) for s, c in zip('abc', [5, 6, 7])]), Set([Couplet(s, c) for s, c in zip('bd', [8, 9])])) types = {'a': int, 'b': int, 'c': int, 'd': int} st3 = import_csv(IoCsvTests.path('set3.csv'), types) # print("expected", clan) # print("actual", st3) self.assertEqual(clan, st3) self.assertEqual(st3.cached_clan, CacheStatus.IS) self.assertEqual(st3.cached_functional, CacheStatus.IS) self.assertEqual(st3.cached_regular, CacheStatus.IS_NOT) expected = Multiset({ Set(Couplet('a', '1'), Couplet('b', '2'), Couplet('c', '3'), Couplet('d', '4')): 1, Set(Couplet('a', '5'), Couplet('b', '6'), Couplet('c', '7')): 1, Set(Couplet('b', '8'), Couplet('d', '9')): 1 }) actual = import_csv(IoCsvTests.path('set3.csv'), has_dup_rows=True) self.assertEqual(actual, expected) self.assertEqual(actual.cached_multiclan, CacheStatus.IS) self.assertEqual(actual.cached_functional, CacheStatus.IS) self.assertEqual(actual.cached_regular, CacheStatus.IS_NOT) expected = Multiset({ Set(Couplet('a', '5'), Couplet('b', '6'), Couplet('c', '7')): 1, Set(Couplet('b', '8'), Couplet('d', '9')): 1, Set(Couplet('a', '1'), Couplet('b', '2'), Couplet('c', '3'), Couplet('d', '4')): 1 }) export_path = IoCsvTests.path('export.csv') self.assertFalse(export_csv(expected, export_path)) self.assertTrue(export_csv(expected, export_path, ordered_lefts='abcd')) actual = import_csv(export_path, has_dup_rows=True) self.assertEqual(actual, expected)
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)