def test___deepcopy__(): """Test copy.deepcopy for AssumptionBase object.""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) vocabulary2 = Vocabulary( ['C1', 'C2', 'C3'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a = AssumptionBase(f1, f2, f3, f4) from copy import deepcopy a_copy = deepcopy(a) assert a == a_copy assert a is not a_copy assert a._vocabulary is a_copy._vocabulary assert a._formulae[0] is not a_copy._formulae[0] assert a._formulae[1] is not a_copy._formulae[1] assert a._formulae[2] is not a_copy._formulae[2] assert a._formulae[3] is not a_copy._formulae[3]
def test___ne__(): """Test != operator for AssumptionBase objects.""" def test_TypeError(self, other): """Test TypeError catching in != operator for AssumptionBase.""" with pytest.raises(TypeError) as excinfo: self != other ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) vocabulary2 = Vocabulary( ['C1', 'C2', 'C3'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a1 = AssumptionBase(f1, f2, f3, f4) a2 = AssumptionBase(f2, f4, f1, f3) a3 = AssumptionBase(f2, f1, f3) a_empty_1 = AssumptionBase(vocabulary) a_empty_2 = AssumptionBase(vocabulary2) test_TypeError(a1, None) test_TypeError(a1, f1) assert not a1 != a1 assert a1 is a1 assert not a1 != a2 assert a1 is not a2 assert a1 != a3 assert a_empty_1 != a_empty_2
def test___iadd__(): """Test + operator for AssumptionBase object.""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) test_rs = RelationSymbol('test', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs, test_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a_1 = AssumptionBase(f1) a_2 = AssumptionBase(f2) a_3 = AssumptionBase(f3) a_1_2 = AssumptionBase(f1, f2) a_1_2_3 = AssumptionBase(f1, f2, f3) a_1_2_3_4 = AssumptionBase(f1, f2, f3, f4) a_1 += a_2 assert a_1 == a_1_2 assert a_1 is not a_1_2 a_1 += (f3 + f4) assert a_1 == a_1_2_3_4 assert a_1 is not a_1_2_3_4 assert f1._vocabulary is f2._vocabulary is f3._vocabulary is \ f4._vocabulary is a_1._vocabulary is a_2._vocabulary is \ a_3._vocabulary is a_1_2._vocabulary is a_1_2_3._vocabulary is \ a_1_2_3_4._vocabulary
def test___ne__(): """Test != operator for ConstantAssignment object.""" vocabulary1 = Vocabulary(['C'], [RelationSymbol('R', 1)], ['V']) vocabulary2 = Vocabulary(['C\''], [RelationSymbol('R\'', 1)], ['V\'']) a = Attribute("a", []) b = Attribute("b", []) astr1 = AttributeStructure(a, b) astr2 = AttributeStructure(b) objs1 = ['a', 'b', 'c'] objs2 = ['a'] attribute_system1 = AttributeSystem(astr1, objs1) attribute_system2 = AttributeSystem(astr2, objs2) mapping1 = {'C': 'a'} mapping2 = {'C': 'b'} A1 = ConstantAssignment(vocabulary1, attribute_system1, mapping1) A2 = ConstantAssignment(vocabulary1, attribute_system1, mapping1) A3 = ConstantAssignment(vocabulary2, attribute_system1, {}) A4 = ConstantAssignment(vocabulary1, attribute_system2, {}) A5 = ConstantAssignment(vocabulary1, attribute_system1, mapping2) assert not A1 != A1 assert not A1 != A2 assert A1 != A3 assert A1 != A4 assert A1 != A5
def test___add__(): """Test + operator for Formula object.""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) vocabulary = Vocabulary(['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a1 = AssumptionBase(f1, f2) a = f1 + f2 assert a._vocabulary is f1._vocabulary is f2._vocabulary a = f2 + f1 assert a._vocabulary is f1._vocabulary is f2._vocabulary assert hasattr(a, "_is_AssumptionBase") a = f3 + a1 assert a._vocabulary is a1._vocabulary is f3._vocabulary assert hasattr(a, "_is_AssumptionBase") a = f1 + f2 + f3 + f4 assert a._vocabulary is f1._vocabulary is f2._vocabulary is f3._vocabulary \ is f4._vocabulary assert hasattr(a, "_is_AssumptionBase") assert len(a) == 4
def test___init__(): """Test Formula constructor.""" def test_TypeError(vocabulary, name, *terms): """Test TypeError catching in Formula constructor.""" with pytest.raises(TypeError) as excinfo: Formula(vocabulary, name, *terms) def test_ValueError(vocabulary, name, *terms): """Test ValueError catching in Formula constructor.""" with pytest.raises(ValueError) as excinfo: Formula(vocabulary, name, *terms) ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) vocabulary = Vocabulary(['C1', 'C2'], [ahead_rs, behind_rs, pm_rs], ['V1', 'V2']) test_TypeError(None, 'Ahead', 'C1', 'V1') test_TypeError(object, 'Ahead', 'C1', 'V1') test_TypeError(vocabulary, None, 'C1', 'V1') test_TypeError(vocabulary, object, 'C1', 'V1') test_ValueError(vocabulary, 'Ahead') test_ValueError(vocabulary, 'Ahead', 'nope') F = Formula(vocabulary, 'Ahead', 'C1', 'C1', 'C1') assert F._terms == ['C1', 'C1', 'C1']
def test___ne__(): """Test != operator for Formula object.""" def test_TypeError(f1, f2): """Test TypeError catching in != operator of Formula.""" with pytest.raises(TypeError) as excinfo: f1 != f2 ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) vocabulary = Vocabulary(['C1', 'C2'], [ahead_rs, behind_rs, pm_rs], ['V1', 'V2']) vocabulary2 = Vocabulary(['C1', 'C2', 'C3'], [ahead_rs, behind_rs, pm_rs], ['V1', 'V2']) f = Formula(vocabulary, 'Ahead', 'C1', 'V1') f1 = Formula(vocabulary, 'Ahead', 'C1') f2 = Formula(vocabulary, 'Ahead', 'V1', 'C1') f3 = Formula(vocabulary, 'Ahead', 'V1', 'C1', 'V1', 'C1') f4 = Formula(vocabulary, 'Behind', 'C1', 'V1') f5 = Formula(vocabulary2, 'Ahead', 'C1', 'V1') test_TypeError(f, None) test_TypeError(f, object) assert not f != f assert f != f1 assert not f != f2 assert not f != f3 assert f != f4 assert f != f5
def test___le__(): """Test overloaded <= subset operator for ConstantAssignment.""" vocabulary1 = Vocabulary(['C1', 'C2', 'C3'], [RelationSymbol('R', 1)], ['V']) vocabulary2 = Vocabulary(['C\''], [RelationSymbol('R\'', 1)], ['V\'']) a = Attribute("a", []) b = Attribute("b", []) astr1 = AttributeStructure(a, b) astr2 = AttributeStructure(b) objs1 = ['a', 'b', 'c'] objs2 = ['a'] attribute_system1 = AttributeSystem(astr1, objs1) attribute_system2 = AttributeSystem(astr2, objs2) mapping1 = {'C1': 'a'} mapping2 = {'C1': 'a', 'C2': 'b'} mapping3 = {'C1': 'a', 'C2': 'b', 'C3': 'c'} mapping4 = {'C\'': 'a'} mapping5 = {'C1': 'b'} CA1 = ConstantAssignment(vocabulary1, attribute_system1, mapping1) CA2 = ConstantAssignment(vocabulary1, attribute_system1, mapping2) CA3 = ConstantAssignment(vocabulary1, attribute_system1, mapping3) CA4 = ConstantAssignment(vocabulary2, attribute_system2, mapping4) CA5 = ConstantAssignment(vocabulary1, attribute_system1, mapping5) assert CA1 <= CA1 assert CA1 <= CA2 assert CA1 <= CA2 <= CA3 assert not CA1 <= CA4 assert not CA4 <= CA1 assert not CA5 <= CA2
def test___repr__(): """Test repr(AttributeInterpretation).""" a = Attribute('hour', ['0,...,23']) a2 = Attribute('minute', ['0,...,59']) r_ahead = Relation('R1(h1,m1,h2,m2) <=> h1 > h2 or (h1 = h2 and m1 > m2)', ['hour', 'minute', 'hour', 'minute'], 1) r_behind = Relation('R2(h1,m1,h2,m2) <=> h1 < h2 or (h1 = h2 and m1 < m2)', ['hour', 'minute', 'hour', 'minute'], 2) r_pm = Relation('R3(h1) <=> h1 > 12', ['hour'], 3) r_am = Relation('R4(h1) <=> h1 < 12', ['hour'], 4) attribute_structure = AttributeStructure( a, a2, r_ahead, r_behind, r_pm, r_am) ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, pm_rs], ['V1', 'V2']) profiles = [ [ahead_rs, ('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)], [behind_rs, ('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)], [pm_rs, ('hour', 1)] ] mapping = {ahead_rs: 1, behind_rs: 2, pm_rs: 3} ai = AttributeInterpretation( vocabulary, attribute_structure, mapping, profiles) assert repr(ai) == "[Ahead, 4, 'R1', [('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)]]\n" + \ "[Behind, 4, 'R2', [('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)]]\n" + \ "[PM, 1, 'R3', [('hour', 1)]]"
def test___hash__(): """Test hash(Vocabulary).""" C, R, V = ['C1', 'C2'], [RelationSymbol('R', 1)], ['V'] vocabulary = Vocabulary(C, R, V) C, R, V = ['C2', 'C1'], [RelationSymbol('R', 1)], ['V'] vocabulary2 = Vocabulary(C, R, V) assert hash(vocabulary) == hash(vocabulary2)
def test___contains__(): """Test in operator for Vocabulary.""" C = ['C'] R = [RelationSymbol('R', 1)] V = ['V'] vocabulary = Vocabulary(C, R, V) assert 'C' in vocabulary assert RelationSymbol('R', 1) in vocabulary assert 'V' in vocabulary
def test___ne__(): """Test != operator for RelationSymbol.""" rs1 = RelationSymbol('name1', 1) rs2 = RelationSymbol('name1', 1) rs3 = RelationSymbol('name1', 2) rs4 = RelationSymbol('name2', 1) assert not rs1 != rs1 assert not rs1 != rs2 assert rs1 != rs3 assert rs1 != rs4
def test___repr__(): """Test repr(Formula).""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) vocabulary = Vocabulary(['C1', 'C2'], [ahead_rs, behind_rs, pm_rs], ['V1', 'V2']) f = Formula(vocabulary, 'Ahead', 'C1', 'V1') assert repr(f) == "Ahead(C1, V1)"
def test___getitem__(): """Test indexing for VariableAssignment object.""" def test_TypeError(variable_assignment, key): """Test constructor for TypeErrors with given params.""" with pytest.raises(TypeError) as excinfo: variable_assignment[key] def test_KeyError(variable_assignment, key): """Test constructor for KeyErrors with given params.""" with pytest.raises(KeyError) as excinfo: variable_assignment[key] vocabulary = Vocabulary(['C'], [RelationSymbol('R', 1)], ['V']) a = Attribute("a", []) b = Attribute("b", []) astr = AttributeStructure(a, b) objs = ['a', 'b', 'c'] attribute_system = AttributeSystem(astr, objs) mapping = {'V': 'a'} VA = VariableAssignment(vocabulary, attribute_system, mapping) test_TypeError(VA, 1) test_TypeError(VA, None) test_TypeError(VA, object) test_KeyError(VA, '') assert VA['V'] == 'a'
def test__key(): """Test key for hash function.""" C, R, V = ['C'], [RelationSymbol('R', 1)], ['V'] vocabulary = Vocabulary(C, R, V) formula = Formula(vocabulary, 'R', 'C', 'V') assert (hash(vocabulary), 'R', ('C', 'V')) == formula._key()
def test___repr__(): """Test repr(AssumptionBase).""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a1 = AssumptionBase(f1, f2, f3, f4) assert repr(a1) == "AB(AM(C1), Ahead(C1, V1), Behind(C1, V1), PM(C1))"
def test___init__(): """Test VariableAssignment constructor.""" def test_TypeError(vocabulary, attribute_system, mapping): """Test constructor for TypeErrors with given params.""" with pytest.raises(TypeError) as excinfo: VariableAssignment(vocabulary, attribute_system, mapping) def test_ValueError(vocabulary, attribute_system, mapping): """Test constructor for ValueErrors with given params.""" with pytest.raises(ValueError) as excinfo: VariableAssignment(vocabulary, attribute_system, mapping) vocabulary = Vocabulary(['C'], [RelationSymbol('R', 1)], ['V']) a = Attribute("a", []) b = Attribute("b", []) astr = AttributeStructure(a, b) objs = ['a', 'b', 'c'] attribute_system = AttributeSystem(astr, objs) test_TypeError(vocabulary, attribute_system, {'V': 1}) test_TypeError(vocabulary, attribute_system, {1: 'a'}) test_ValueError(vocabulary, attribute_system, {'V': 'bad'}) test_ValueError(vocabulary, attribute_system, {'bad': 'a'}) VA = VariableAssignment(vocabulary, attribute_system, {'V': 'a'})
def test___deepcopy__(): """Test copy.deepcopy for RelationSymbol object.""" from copy import deepcopy r = RelationSymbol('name', 1) r_copy = deepcopy(r) assert r == r_copy assert r is not r_copy
def test___ne__(): """Test != operator for Vocabulary.""" C = ['C'] R = [RelationSymbol('R', 1)] V = ['V'] vocab = Vocabulary(C, R, V) vocab_copy = Vocabulary(C, R, V) C = ['C\''] R = [RelationSymbol('R\'', 1)] V = ['V\''] vocab_prime = Vocabulary(C, R, V) assert not vocab != vocab assert not vocab != vocab_copy assert vocab is not vocab_copy assert vocab != vocab_prime
def test___hash__(): """Test hash(Vocabulary).""" C, R, V = ['C'], [RelationSymbol('R', 1)], ['V'] vocabulary = Vocabulary(C, R, V) formula1 = Formula(vocabulary, 'R', 'C', 'V') formula2 = Formula(vocabulary, 'R', 'V', 'C') assert hash(formula1) == hash(formula2)
def test___add__(): """Test + operator for AssumptionBase object.""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) test_rs = RelationSymbol('test', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs, test_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a_empty = AssumptionBase(vocabulary) a_1 = AssumptionBase(f1) a_2 = AssumptionBase(f2) a_3 = AssumptionBase(f3) a_1_2 = AssumptionBase(f1, f2) a_1_2_3 = AssumptionBase(f1, f2, f3) a_1_2_3_4 = AssumptionBase(f1, f2, f3, f4) assert a_1 == a_empty + f1 assert a_1 == f1 + a_empty assert a_1 == a_empty + a_1 assert a_1 == a_1 + a_empty assert a_1_2 == a_1 + f2 assert a_1_2 == f2 + a_1 assert a_1_2 is not a_1 assert a_1_2 is not f2 ref_a = a_1 + f2 f2._name = "test" assert ref_a[-1]._name != f2._name assert a_1_2 == a_1 + a_2 assert a_1_2_3 == a_1 + a_2 + a_3 assert a_1_2_3 == a_1 + f2 + f3 assert a_1_2_3_4 == a_1 + f2 + f3 + f4 assert f1._vocabulary is f2._vocabulary is f3._vocabulary is \ f4._vocabulary is a_1._vocabulary is a_2._vocabulary is \ a_3._vocabulary is a_1_2._vocabulary is a_1_2_3._vocabulary is \ a_1_2_3_4._vocabulary is a_empty._vocabulary
def test___len__(): """Test len(AssumptionBase).""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) vocabulary2 = Vocabulary( ['C1', 'C2', 'C3'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a1 = AssumptionBase(f1, f2, f3, f4) assert len(AssumptionBase(vocabulary)) == 0 assert len(a1) == 4
def test___repr__(): """Test repr(Vocabulary).""" C = ['C'] R = [RelationSymbol('R', 1)] V = ['V'] vocab = Vocabulary(C, R, V) assert vocab.__repr__() == "([C], [R], [V])" vocab_empty = Vocabulary([], [], []) assert vocab_empty.__repr__() == "([], [], [])"
def test___getitem__(): """Test indexing of AssumptionBase object.""" def test_KeyError(assumption_base, key): """Test KeyError catching in AssumptionBase constructor.""" with pytest.raises(KeyError) as excinfo: assumption_base[key] def test_IndexError(assumption_base, key): """Test IndexError catching in AssumptionBase constructor.""" with pytest.raises(IndexError) as excinfo: assumption_base[key] def test_TypeError(assumption_base, key): """Test TypeError catching in AssumptionBase constructor.""" with pytest.raises(TypeError) as excinfo: assumption_base[key] ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) vocabulary2 = Vocabulary( ['C1', 'C2', 'C3'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a = AssumptionBase(f1, f2, f3) test_TypeError(a, None) test_TypeError(a, object) test_KeyError(a, 'AM') test_KeyError(a, f4) test_IndexError(a, 4) test_IndexError(a, 1000) assert a[f1] is f1 assert a['Behind'] is f2 assert a[2] is f3
def test___deepcopy__(): """Test Test copy.deepcopy for Formula object.""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) vocabulary = Vocabulary(['C1', 'C2'], [ahead_rs, behind_rs, pm_rs], ['V1', 'V2']) f = Formula(vocabulary, 'Ahead', 'C1', 'V1') from copy import deepcopy f_copy = deepcopy(f) assert f == f_copy assert f is not f_copy assert f._vocabulary is f_copy._vocabulary assert f._terms is not f_copy._terms f._name = "F" assert f._name != f_copy._name
def test___repr__(): """Test str(Context).""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) vocabulary = Vocabulary(['C1', 'C2'], [ahead_rs, behind_rs, pm_rs, am_rs], ['V1', 'V2']) f = Formula(vocabulary, 'Ahead', 'C1', 'V1') a = Attribute('hour', [Interval(0, 23)]) a2 = Attribute('minute', [Interval(0, 59)]) r_pm = Relation('R1(h1) <=> h1 > 11', ['hour'], 1) r_am = Relation('R2(h1) <=> h1 <= 11', ['hour'], 2) r_ahead = Relation( 'R3(h1,m1,hhh2,mm2) <=> h1 > hhh2 or (h1 = hhh2 and m1 > mm2)', ['hour', 'minute', 'hour', 'minute'], 3) r_behind = Relation( 'R4(h1,m1,h2,m2) <=> h1 <= h2 or (h1 = h2 and m1 < m2)', ['hour', 'minute', 'hour', 'minute'], 4) attribute_structure = AttributeStructure(a, a2, r_ahead, r_behind, r_pm, r_am) objects = ['s1', 's2'] attribute_system = AttributeSystem(attribute_structure, objects) p = ConstantAssignment(vocabulary, attribute_system, { 'C1': 's1', 'C2': 's2' }) assumption_base = AssumptionBase(f) named_state = NamedState(attribute_system, p) C = Context(assumption_base, named_state) assert repr(C) == "hour(s1): {V(I(0, 23))}\n" + \ "hour(s2): {V(I(0, 23))}\n" + \ "minute(s1): {V(I(0, 59))}\n" + \ "minute(s2): {V(I(0, 59))}\n" + \ "CA{'C2': 's2', 'C1': 's1'}\n" + \ "AB(Ahead(C1, V1))"
def test_is_total(): """Test is_total function for ConstantAssignment object.""" vocabulary = Vocabulary(['C', 'C\''], [RelationSymbol('R', 1)], ['V']) vocabulary_total = Vocabulary(['C1', 'C2', 'C3'], [RelationSymbol('R', 1)], ['V']) a = Attribute("a", []) b = Attribute("b", []) astr = AttributeStructure(a, b) objs = ['a', 'b', 'c'] attribute_system = AttributeSystem(astr, objs) mapping = {'C': 'a'} total_mapping = {'C1': 'a', 'C2': 'b', 'C3': 'c'} CA = ConstantAssignment(vocabulary, attribute_system, mapping) CA_total = ConstantAssignment(vocabulary_total, attribute_system, total_mapping) assert not CA.is_total() assert CA_total.is_total()
def test___contains__(): """Test in and not in operators for AssumptionBase object.""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) vocabulary2 = Vocabulary( ['C1', 'C2', 'C3'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a1 = AssumptionBase(f1, f2, f3) assert f1 in a1 assert f2 in a1 assert f3 in a1 assert f4 not in a1
def test___iter__(): """Test iterator for AssumptionBase.""" ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) am_rs = RelationSymbol('AM', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) vocabulary2 = Vocabulary( ['C1', 'C2', 'C3'], [ahead_rs, behind_rs, am_rs, pm_rs], ['V1', 'V2']) f1 = Formula(vocabulary, 'Ahead', 'C1', 'V1') f2 = Formula(vocabulary, 'Behind', 'C1', 'V1') f3 = Formula(vocabulary, 'PM', 'C1') f4 = Formula(vocabulary, 'AM', 'C1') a1 = AssumptionBase(f1, f2, f3, f4) assert set([f1, f2, f3, f4]) == set([f for f in a1]) assert set([f1, f2, f3, f4]) == set([f for f in iter(a1)]) assert set([f1, f2, f3, f4]) == set(a1) assert set([f1, f2, f3, f4]) == set(iter(a1))
def test___deepcopy__(): """Test copy.deepcopy for AttributeInterpretation object.""" a = Attribute('hour', ['0,...,23']) a2 = Attribute('minute', ['0,...,59']) r_ahead = Relation('R1(h1,m1,h2,m2) <=> h1 > h2 or (h1 = h2 and m1 > m2)', ['hour', 'minute', 'hour', 'minute'], 1) r_behind = Relation('R2(h1,m1,h2,m2) <=> h1 < h2 or (h1 = h2 and m1 < m2)', ['hour', 'minute', 'hour', 'minute'], 2) r_pm = Relation('R3(h1) <=> h1 > 12', ['hour'], 3) r_am = Relation('R4(h1) <=> h1 < 12', ['hour'], 4) attribute_structure = AttributeStructure( a, a2, r_ahead, r_behind, r_pm, r_am) ahead_rs = RelationSymbol('Ahead', 4) behind_rs = RelationSymbol('Behind', 4) pm_rs = RelationSymbol('PM', 1) vocabulary = Vocabulary( ['C1', 'C2'], [ahead_rs, behind_rs, pm_rs], ['V1', 'V2']) profiles = [ [ahead_rs, ('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)], [behind_rs, ('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)], [pm_rs, ('hour', 1)]] mapping = {ahead_rs: 1, behind_rs: 2, pm_rs: 3} ai = AttributeInterpretation( vocabulary, attribute_structure, mapping, profiles) from copy import deepcopy ai_copy = deepcopy(ai) assert ai == ai_copy assert ai is not ai_copy assert ai._vocabulary is ai_copy._vocabulary assert ai._attribute_structure is not ai_copy._attribute_structure assert ai._mapping is not ai_copy._mapping assert ai._profiles is not ai_copy._profiles assert ai._table is not ai_copy._table assert ai._relation_symbols is not ai_copy._relation_symbols
def test__key(): """Test key for RelationSymbol hashing.""" r = RelationSymbol('name', 1) assert r._key() == ('name', 1)
def test___repr__(): """Test repr(RelationSymbol.""" rs1 = RelationSymbol('name', 1) rs2 = RelationSymbol('', 1) assert rs1.__repr__() == 'name' assert rs2.__repr__() == ''