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 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___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___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___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___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__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(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___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___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___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___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___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 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___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___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___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___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___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_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___init__(): """Test AssumptionBase constructor.""" def test_TypeError(*formulae): """Test TypeError catching in AssumptionBase constructor.""" with pytest.raises(TypeError) as excinfo: AssumptionBase(*formulae) def test_ValueError(*formulae): """Test ValueError catching in AssumptionBase constructor.""" with pytest.raises(ValueError) as excinfo: AssumptionBase(*formulae) 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(vocabulary2, 'AM', 'C1') a1 = AssumptionBase(f1, f2, f3) a_empty = AssumptionBase(vocabulary) test_TypeError(f1, None) test_TypeError(f1, object) test_ValueError(f1, f1) test_ValueError(f1, f4) assert a1[0] is f1 assert a1[1] is f2 assert a1[2] is f3 assert a1._vocabulary is f1._vocabulary is f2._vocabulary is \ f3._vocabulary is a_empty._vocabulary
def test___eq__(): """Test == operator for VariableAssignment 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 = {'V': 'a'} mapping2 = {'V': 'b'} A1 = VariableAssignment(vocabulary1, attribute_system1, mapping1) A2 = VariableAssignment(vocabulary1, attribute_system1, mapping1) A3 = VariableAssignment(vocabulary1, attribute_system1, mapping2) assert A1 == A1 assert A1 == A2 assert not A1 == A3
def test___repr__(): """Test repr(VariableAssignment).""" vocabulary = Vocabulary(['C', '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) assert VA.__repr__() == "VA{'V': 'a'}"
def test___deepcopy__(): """Test copy.deepcopy for Vocabulary.""" from copy import deepcopy C = ['C'] R = [RelationSymbol('R', 1)] V = ['V'] vocab = Vocabulary(C, R, V) vocab_copy = deepcopy(vocab) assert vocab == vocab_copy assert vocab is not vocab_copy assert vocab._C is not vocab_copy._C assert vocab._R is not vocab_copy._R assert vocab._V is not vocab_copy._V
def test___init__(): """Test Assignment constructor.""" def test_TypeError(vocabulary, attribute_system): """Test constructor for TypeErrors with given params.""" with pytest.raises(TypeError) as excinfo: Assignment(vocabulary, attribute_system) 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 type errors test_TypeError(None, attribute_system) test_TypeError('', attribute_system) test_TypeError(object, attribute_system) test_TypeError(vocabulary, None) test_TypeError(vocabulary, '') test_TypeError(vocabulary, object) # test reference keeping and breaking A = Assignment(vocabulary, attribute_system) assert vocabulary is A._vocabulary assert attribute_system is not A._attribute_system vocabulary.add_constant('cx') vocabulary.add_variable('vx') assert 'cx' in A._vocabulary._C assert 'vx' in A._vocabulary._V A._vocabulary.add_constant('cx2') A._vocabulary.add_variable('vx2') assert 'cx2' in vocabulary._C assert 'vx2' in vocabulary._V
def test_add_variable(): """Test add_variable() function for Vocabulary object.""" def test_TypeError(vocabulary, v): """Test TypeErrors in add_constant.""" with pytest.raises(TypeError) as excinfo: vocabulary.add_variable(v) def test_ValueError(vocabulary, v): """Test ValueErrors in add constant.""" with pytest.raises(ValueError) as excinfo: vocabulary.add_variable(v) C, R, V = ["C"], [RelationSymbol("R", 1)], ["V"] vocab = Vocabulary(C, R, V) test_TypeError(vocab, None) test_TypeError(vocab, object) test_ValueError(vocab, "C") test_ValueError(vocab, "V") vocab.add_variable("x") assert vocab._V == ["V", "x"] vocab.add_variable("a") assert vocab._V == ["a", "V", "x"]
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___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___repr__(): """Test repr(ConstantAssignment).""" vocabulary = Vocabulary(['C', '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 = {'C': 'a'} mapping2 = {'C': 'a', 'C\'': 'b'} CA = ConstantAssignment(vocabulary, attribute_system, mapping) CA2 = ConstantAssignment(vocabulary, attribute_system, mapping2) assert CA.__repr__() == "CA{'C': 'a'}" assert CA2.__repr__() == "CA{'C': 'a', \"C\'\": 'b'}"
def test_get_domain(): """Test get_domain function for ConstantAssignment object.""" vocabulary = Vocabulary(['C', '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 = {'C': 'a'} mapping2 = {'C': 'a', 'C\'': 'b'} CA = ConstantAssignment(vocabulary, attribute_system, mapping) CA2 = ConstantAssignment(vocabulary, attribute_system, mapping2) assert CA.get_domain() == ['C'] assert CA2.get_domain() == ['C', "C'"]
def test___init__(): """Test AttributeInterpretation constructor.""" def test_TypeError(vocabulary, attribute_structure, mapping, profiles): """Test TypeError catching in AttributeInterpretation constructor.""" with pytest.raises(TypeError) as excinfo: AttributeInterpretation( vocabulary, attribute_structure, mapping, profiles) def test_ValueError(vocabulary, attribute_structure, mapping, profiles): """Test ValueError catching in AttributeInterpretation constructor.""" with pytest.raises(ValueError) as excinfo: AttributeInterpretation( vocabulary, attribute_structure, mapping, profiles) 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)]] bad_profiles = [ [behind_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} bad_source_mapping = {ahead_rs: 1, "behind_rs": 2, pm_rs: 3} bad_target_mapping = {ahead_rs: 1, behind_rs: 'R2', pm_rs: 3} bad_target_mapping2 = {ahead_rs: 1, behind_rs: 2.0, pm_rs: 3} dup_subscr_mapping = {ahead_rs: 2, behind_rs: 2, pm_rs: 3} ai = AttributeInterpretation( vocabulary, attribute_structure, mapping, profiles) test_TypeError(None, attribute_structure, mapping, profiles) test_TypeError(object, attribute_structure, mapping, profiles) test_TypeError(vocabulary, None, mapping, profiles) test_TypeError(vocabulary, object, mapping, profiles) test_TypeError(vocabulary, AttributeSystem(attribute_structure, ['o']), mapping, profiles) test_TypeError(vocabulary, attribute_structure, None, profiles) test_TypeError(vocabulary, attribute_structure, object, profiles) test_TypeError(vocabulary, attribute_structure, mapping, None) test_TypeError(vocabulary, attribute_structure, mapping, object) test_ValueError( vocabulary, attribute_structure, bad_source_mapping, profiles) test_ValueError( vocabulary, attribute_structure, bad_target_mapping, profiles) test_ValueError( vocabulary, attribute_structure, bad_target_mapping2, profiles) test_ValueError(vocabulary, attribute_structure, mapping, bad_profiles) test_ValueError( vocabulary, attribute_structure, dup_subscr_mapping, profiles) bad_mapping = {RelationSymbol("not in Vocabulary or profiles", 2): 1, behind_rs: 2, pm_rs: 3} test_ValueError(vocabulary, attribute_structure, bad_mapping, profiles) bad_vocabulary = Vocabulary(['C1', 'C2'], [ahead_rs, behind_rs, pm_rs, RelationSymbol("not in source/profiles", 2)], ['V1', 'V2']) test_ValueError(bad_vocabulary, attribute_structure, mapping, profiles) bad_target_mapping = {ahead_rs: 1, behind_rs: 6, pm_rs: 3} test_ValueError( vocabulary, attribute_structure, bad_target_mapping, profiles) bad_profiles = [ [ahead_rs, ('doesn\'t exist', 1), ('minute', 1), ('hour', 2), ('minute', 2)], [behind_rs, ('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)], [pm_rs, ('hour', 1)]] test_ValueError(vocabulary, attribute_structure, mapping, bad_profiles) bad_profiles = [ [ahead_rs, ('hour', 10), ('minute', 1), ('hour', 2), ('minute', 2)], [behind_rs, ('hour', 1), ('minute', 1), ('hour', 2), ('minute', 2)], [pm_rs, ('hour', 1)]] test_ValueError(vocabulary, attribute_structure, mapping, bad_profiles) AI = AttributeInterpretation( vocabulary, attribute_structure, mapping, profiles) assert AI._attribute_structure == attribute_structure assert AI._attribute_structure is not attribute_structure assert AI._vocabulary == vocabulary assert AI._vocabulary is vocabulary AI._vocabulary.add_constant('cx') AI._vocabulary.add_variable('vx') assert 'cx' in vocabulary._C assert 'vx' in vocabulary._V vocabulary.add_constant('cx2') vocabulary.add_variable('vx2') assert 'cx2' in AI._vocabulary._C assert 'vx2' in AI._vocabulary._V
def test_memory_binding(): """Test that a vocabulary is shared across all objects that use it.""" from vivid.classes.attribute import Attribute from vivid.classes.relation import Relation from vivid.classes.attribute_structure import AttributeStructure from vivid.classes.attribute_system import AttributeSystem from vivid.classes.constant_assignment import ConstantAssignment from vivid.classes.variable_assignment import VariableAssignment from vivid.classes.named_state import NamedState from vivid.classes.formula import Formula from vivid.classes.assumption_base import AssumptionBase from vivid.classes.attribute_interpretation import AttributeInterpretation from vivid.classes.context import Context color = Attribute("color", ["R", "G", "B"]) size = Attribute("size", ["S", "M", "L"]) r = Relation("R1(c) <=> c", ["color"], 1) attribute_structure = AttributeStructure(color, size, r) o = ["s1", "s2"] attribute_system = AttributeSystem(attribute_structure, o) dummy_rs = RelationSymbol("DUMMY", 3) vocabulary = Vocabulary(["dummy"], [dummy_rs], []) p = ConstantAssignment(vocabulary, attribute_system, {}) p2 = ConstantAssignment(vocabulary, attribute_system, {}) X = VariableAssignment(vocabulary, attribute_system, {}) s = NamedState(attribute_system, p) s2 = NamedState(attribute_system, p2) f = Formula(vocabulary, "DUMMY", "dummy") assumption_base = AssumptionBase(f) context = Context(assumption_base, s) profiles = [[dummy_rs, ("color", 1)]] mapping = {dummy_rs: 1} attribute_interpretation = AttributeInterpretation(vocabulary, attribute_structure, mapping, profiles) vocabulary.add_constant("Vocabulary") p._vocabulary.add_constant("constant") X._vocabulary.add_variable("variable") s._p._vocabulary.add_constant("named_state") f._vocabulary.add_constant("formula") assumption_base._vocabulary.add_constant("assumption_base") context._named_state._p._vocabulary.add_constant("context") attribute_interpretation._vocabulary.add_constant("attribute_interpretation") assert ( str(vocabulary) == str(p._vocabulary) == str(X._vocabulary) == str(s._p._vocabulary) == str(f._vocabulary) == str(assumption_base._vocabulary) == str(context._named_state._p._vocabulary) == str(attribute_interpretation._vocabulary) ) assert vocabulary is p._vocabulary assert vocabulary is X._vocabulary assert vocabulary is s._p._vocabulary assert vocabulary is f._vocabulary assert vocabulary is assumption_base._vocabulary assert vocabulary is context._named_state._p._vocabulary assert vocabulary is attribute_interpretation._vocabulary from copy import deepcopy p_copy = deepcopy(p) X_copy = deepcopy(X) s_copy = deepcopy(s) f_copy = deepcopy(f) assumption_base_copy = deepcopy(assumption_base) context_copy = deepcopy(context) attribute_interpretation_copy = deepcopy(attribute_interpretation) assert vocabulary is p_copy._vocabulary assert vocabulary is X_copy._vocabulary assert vocabulary is s_copy._p._vocabulary assert vocabulary is f_copy._vocabulary assert vocabulary is assumption_base_copy._vocabulary assert vocabulary is context_copy._named_state._p._vocabulary assert vocabulary is attribute_interpretation_copy._vocabulary
def test__key(): """Test key for hash function.""" C, R, V = ["C"], [RelationSymbol("R", 1)], ["V"] vocabulary = Vocabulary(C, R, V) assert (("C",), (RelationSymbol("R", 1),), ("V",)) == vocabulary._key()