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___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
Example #3
0
def test___eq__():
    """Test == operator for AttributeSystem."""
    a = Attribute("a", [])
    b = Attribute("b", [])
    R1 = Relation("R1(a) <=> ", ["a"], 1)
    R2 = Relation("R2(a) <=> ", ["b"], 2)

    astr_empty = AttributeStructure()
    astr_a_b = AttributeStructure(a, b)
    astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)

    objs_empty = []
    objs = ['a', 'b', 'c']

    asys = AttributeSystem(astr_empty, objs_empty)
    asys_o = AttributeSystem(astr_empty, objs)
    asys_o_copy = AttributeSystem(astr_empty, objs)

    asys_a_b = AttributeSystem(astr_a_b, objs_empty)
    asys_a_b_copy = AttributeSystem(astr_a_b, objs_empty)

    asys_a_b_R1_R2 = AttributeSystem(astr_a_b_R1_R2, objs_empty)
    asys_a_b_R1_R2_copy = AttributeSystem(astr_a_b_R1_R2, objs_empty)

    asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)
    asys_a_b_R1_R2_o_copy = AttributeSystem(astr_a_b_R1_R2, objs)

    # test identity
    assert asys == asys
    # components tests
    assert asys_o == asys_o_copy
    assert asys_a_b == asys_a_b_copy
    assert asys_a_b_R1_R2 == asys_a_b_R1_R2_copy
    assert asys_a_b_R1_R2_o == asys_a_b_R1_R2_o_copy
Example #4
0
def test___repr__():
    """Test repr()."""
    a = Attribute("a", [])
    b = Attribute("b", [])
    R1 = Relation("R1(a) <=> ", ["a"], 1)
    R2 = Relation("R2(a) <=> ", ["b"], 2)

    astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
    objs = ['a', 'b', 'c']

    asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)
    assert repr(asys_a_b_R1_R2_o) == "({a, b, c} ; (a: {}, b: {} ; R1,R2))"
    assert repr(AttributeSystem(AttributeStructure(), [])) == "({} ; ( ; ))"
Example #5
0
def test_is_alternate_extension():
    """Test is_alternate_extension function."""
    from copy import deepcopy
    color, size = Attribute("color", ['R', 'G', 'B']), Attribute(
        "size", ['S', 'M', 'L'])

    a = AttributeStructure(color, size)
    o = ['s1', 's2']

    asys = AttributeSystem(a, o)
    s = State(asys)

    s.set_ascription(('color', 's1'), ['R', 'B'])
    s.set_ascription(('size', 's2'), ['M', 'L'])

    s1 = deepcopy(s)
    s1.set_ascription(('color', 's1'), ['B'])
    s1.set_ascription(('size', 's1'), ['S', 'M'])
    s1.set_ascription(('color', 's2'), ['B', 'G'])
    s2 = deepcopy(s)
    s2.set_ascription(('size', 's1'), ['L'])
    s2.set_ascription(('size', 's2'), ['L'])
    s3 = deepcopy(s)
    s3.set_ascription(('color', 's1'), ['R'])

    aes = s.get_alternate_extensions(s1, s2, s3)
    ae_s5, ae_s6, ae_s4 = aes

    for ae in aes:
        print s.is_alternate_extension(ae, s1, s2, s3)

    color, size = Attribute("color", ['R', 'G', 'B']), Attribute(
        "size", ['S', 'M', 'L'])

    a = AttributeStructure(color, size)
    o = ['s']

    asys = AttributeSystem(a, o)
    s = State(asys)

    s1 = deepcopy(s)
    s1.set_ascription(('color', 's'), ['B', 'G'])
    s1.set_ascription(('size', 's'), ['S'])

    aes = s.get_alternate_extensions(s1)
    ae_s2, ae_s3 = aes

    for ae in aes:
        print s.is_alternate_extension(ae, s1)
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'})
Example #7
0
def test___getitem__():
    """Test indexing of AttributeSystem."""
    a = Attribute("a", [])
    b = Attribute("b", [])
    R1 = Relation("R1(a) <=> ", ["a"], 1)
    R2 = Relation("R2(a) <=> ", ["b"], 2)

    astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
    objs = ['a', 'b', 'c']

    asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)

    ia = asys_a_b_R1_R2_o[a]
    assert ia == a
    assert ia is asys_a_b_R1_R2_o._attribute_structure["a"]
    iR1 = asys_a_b_R1_R2_o[R1]
    assert iR1 == R1
    assert iR1 is asys_a_b_R1_R2_o._attribute_structure["R1"]
    # Test object retrieval with string. Note, strings may not index
    # AttributeStructure members within this AttributeSystem, only objects.
    # To index objects in AttributeStructure in AttributeSystem, use index
    # with asys.astr[index]
    iobj = asys_a_b_R1_R2_o['a']
    assert iobj == objs[0]
    assert iobj is objs[0]

    # Test retrieval by string for AttributeStructure members
    # AttributeStructure is cloned so the retrieved objects is not the same
    # as the one's used to contruct original instance
    ias = asys_a_b_R1_R2_o._attribute_structure['a']
    assert ias == a
    assert ias is not a
    iR1s = asys_a_b_R1_R2_o._attribute_structure['R1']
    assert iR1s == R1
    assert iR1s is not R1
Example #8
0
def test___deepcopy__():
    """Test deepcopy"""
    color = Attribute("color", ['R', 'G', 'B'])
    size = Attribute("size", ['S', 'M', 'L'])
    a = AttributeStructure(color, size)
    o = ['s1', 's2']
    asys = AttributeSystem(a, o)

    ascr = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['B', 'G'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['L', 'S']
    }

    s = State(asys, ascr)

    from copy import deepcopy
    s_copy = deepcopy(s)

    assert s == s_copy
    assert s is not s_copy
    assert s._attribute_system == s_copy._attribute_system
    assert s._attribute_system is not s_copy._attribute_system
    assert s._ascriptions == s_copy._ascriptions
    assert s._ascriptions is not s_copy._ascriptions
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_is_automorphic():
    """Test if system is automorphic."""
    a = Attribute("a", [])
    b = Attribute("b", [])
    c = Attribute("c", ['a'])
    R1 = Relation("R1(a) <=> ", ["a"], 1)
    R2 = Relation("R2(a) <=> ", ["b"], 2)

    astr_c = AttributeStructure(c)
    astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
    objs = ['a', 'b', 'c']

    asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)
    asys_auto = AttributeSystem(astr_c, objs)

    assert asys_auto.is_automorphic()
    assert not asys_a_b_R1_R2_o.is_automorphic()
Example #11
0
def test_join():
    """Test join function for States."""
    def test_ValueError(s1, s2):
        """Test constructor for ValueErrors with given params."""
        with pytest.raises(ValueError) as excinfo:
            State.join(s1, s2)

    color = Attribute("color", ['R', 'G', 'B'])
    size = Attribute("size", ['S', 'M', 'L'])
    a = AttributeStructure(color, size)
    o = ['s1', 's2']
    asys = AttributeSystem(a, o)

    ascr1 = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['B'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['L', 'S']
    }
    ascr2 = {
        ('color', 's1'): ['G'],
        ('color', 's2'): ['G'],
        ('size', 's1'): ['L'],
        ('size', 's2'): ['M', 'S']
    }
    ascr3 = {
        ('color', 's1'): ['R', 'G'],
        ('color', 's2'): ['B', 'G'],
        ('size', 's1'): ['L', 'M'],
        ('size', 's2'): ['M', 'S', 'L']
    }

    s1 = State(asys, ascr1)
    s2 = State(asys, ascr2)
    s3 = State(asys, ascr3)

    assert s3 == State.join(s1, s2)

    length = Attribute("length", [1, 3, 5])
    shape = Attribute("shape", ['circle', 'triangle', 'rectangle'])
    a = AttributeStructure(length, shape)
    o = ['s1', 's2']
    bad_asys = AttributeSystem(a, o)
    bad_state = State(bad_asys)

    test_ValueError(s1, bad_state)
Example #12
0
def test_set_ascription():
    """Test set_ascription function."""
    def test_TypeError(state, ascription, valueset):
        """Test set_ascription for TypeErrors with given params."""
        with pytest.raises(TypeError) as excinfo:
            state.set_ascription(ascription, valueset)

    def test_ValueError(state, ascription, valueset):
        """Test set_ascription for ValueErrors with given params."""
        with pytest.raises(ValueError) as excinfo:
            state.set_ascription(ascription, valueset)

    def test_KeyError(state, ascription, valueset):
        """Test set_ascription for KeyErrors with given params."""
        with pytest.raises(KeyError) as excinfo:
            state.set_ascription(ascription, valueset)

    color = Attribute("color", ['R', 'G', 'B'])
    size = Attribute("size", ['S', 'M', 'L'])

    a = AttributeStructure(color, size)
    o = ['s1', 's2']

    asys = AttributeSystem(a, o)
    s = State(asys)

    # test bad ao_pair types/values
    test_TypeError(s, [], ['R'])
    test_ValueError(s, (), ['R'])
    test_ValueError(s, (1, 2, 3), ['R'])
    test_ValueError(s, (1, 2), ['R'])
    test_ValueError(s, (1, ''), ['R'])
    test_ValueError(s, ('', 1), ['R'])
    # test bad types for ValueSet
    test_TypeError(s, ('color', 's1'), None)
    test_TypeError(s, ('color', 's1'), ())
    test_TypeError(s, ('color', 's1'), 'a')
    test_TypeError(s, ('color', 's1'), object)
    # test empty ValueSet catching
    test_ValueError(s, ('color', 's1'), [])
    test_ValueError(s, ('color', 's1'), set([]))
    test_ValueError(s, ('color', 's1'), ValueSet([]))
    # test bad ao-pair keys
    test_KeyError(s, ('color', 'bad object'), ['R'])
    test_KeyError(s, ('bad label', 's2'), ['R'])
    # test nonsubset valuesets
    test_ValueError(s, ('color', 's2'), ['a'])
    test_ValueError(s, ('color', 's2'), [1])

    s.set_ascription(('color', 's2'), ['R'])
    assert s[('color', 's2')] == ValueSet(['R'])
    # check reversion to superset is possible
    s.set_ascription(('color', 's2'), ['R', 'G'])
    assert s[('color', 's2')] == ValueSet(['R', 'G'])
    s.set_ascription(('size', 's1'), ['M', 'S'])
    assert s[('size', 's1')] == ValueSet(['S', 'M'])
Example #13
0
def test_get_worlds():
    """Test get_worlds function."""
    color = Attribute("color", ['R', 'G', 'B'])
    size = Attribute("size", ['S', 'M', 'L'])
    a = AttributeStructure(color, size)
    o = ['s1', 's2']
    asys = AttributeSystem(a, o)

    ascr = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['B', 'G'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['L', 'S']
    }

    ascr1 = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['G'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['L']
    }

    ascr2 = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['G'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['S']
    }

    ascr3 = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['B'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['L']
    }

    ascr4 = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['B'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['S']
    }

    s = State(asys, ascr)

    w1 = State(asys, ascr1)
    w2 = State(asys, ascr2)
    w3 = State(asys, ascr3)
    w4 = State(asys, ascr4)
    worlds = [w1, w2, w3, w4]

    for w in s.get_worlds():
        assert w in worlds

    assert len(s.get_worlds()) == len(worlds)
Example #14
0
def test___isub__():
    """Test -= operator for AttributeSystem."""
    a = Attribute("a", [])
    b = Attribute("b", [])
    R1 = Relation("R1(a) <=> ", ["a"], 1)
    R2 = Relation("R2(a) <=> ", ["b"], 2)

    astr_empty = AttributeStructure()
    astr_a = AttributeStructure(a)
    astr_a_b = AttributeStructure(a, b)
    astr_a_R1 = AttributeStructure(a, R1)
    astr_a_b_R1 = AttributeStructure(a, b, R1)
    astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)

    objs = ['a', 'b', 'c']

    asys = AttributeSystem(astr_empty, [])
    asys_a = AttributeSystem(astr_a, [])
    asys_a_b = AttributeSystem(astr_a_b, [])
    asys_a_R1 = AttributeSystem(astr_a_R1, [])
    asys_a_b_R1 = AttributeSystem(astr_a_b_R1, [])
    asys_a_b_R1_R2 = AttributeSystem(astr_a_b_R1_R2, [])

    asys_a_b_R1_R2 -= R2
    assert asys_a_b_R1_R2 == asys_a_b_R1
    assert asys_a_b_R1_R2 is not asys_a_b_R1
    asys_a_b_R1_R2 -= R1
    assert asys_a_b_R1_R2 == asys_a_b
    assert asys_a_b_R1_R2 is not asys_a_b
    asys_a_b_R1_R2 -= b
    assert asys_a_b_R1_R2 == asys_a
    assert asys_a_b_R1_R2 is not asys_a
    asys_a_b_R1_R2 -= a
    assert asys_a_b_R1_R2 == asys
    assert asys_a_b_R1_R2 is not asys
Example #15
0
def test___contains__():
    """Test "in" operator for AttributeSystem."""
    a = Attribute("a", [])
    b = Attribute("b", [])
    R1 = Relation("R1(a) <=> ", ["a"], 1)
    R2 = Relation("R2(a) <=> ", ["b"], 2)

    astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
    objs = ['a', 'b', 'c']

    asys_a_b_R1_R2 = AttributeSystem(astr_a_b_R1_R2, [])
    asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)

    assert a in asys_a_b_R1_R2_o
    assert R1 in asys_a_b_R1_R2_o
    assert astr_a_b_R1_R2 in asys_a_b_R1_R2
    assert astr_a_b_R1_R2 in asys_a_b_R1_R2_o
    with pytest.raises(TypeError) as excinfo:
        asys_a_b_R1_R2 in asys_a_b_R1_R2_o
    # Test strings only checked against objects
    assert 'a' not in asys_a_b_R1_R2
    assert 'a' in asys_a_b_R1_R2._attribute_structure
    assert 'a' in asys_a_b_R1_R2_o
Example #16
0
def test___repr__():
    """Test repr(State)."""
    color = Attribute("color", ['R', 'G', 'B'])
    size = Attribute("size", ['S', 'M', 'L'])
    a = AttributeStructure(color, size)
    o = ['s1', 's2']
    asys = AttributeSystem(a, o)

    s = State(asys)
    s1 = State(
        asys, {
            ('color', 's1'): ['R'],
            ('color', 's2'): ['B', 'G'],
            ('size', 's1'): ['M'],
            ('size', 's2'): ['L', 'S']
        })

    s_empty = State(AttributeSystem(AttributeStructure(), []))
    assert s_empty.__repr__() == ""
    assert s.__repr__(
    ) == "color(s1): {V(B, G, R)}\ncolor(s2): {V(B, G, R)}\nsize(s1): {V(L, M, S)}\nsize(s2): {V(L, M, S)}"
    assert s1.__repr__(
    ) == "color(s1): {V(R)}\ncolor(s2): {V(B, G)}\nsize(s1): {V(M)}\nsize(s2): {V(L, S)}"
Example #17
0
def test_is_disjoint():
    """Test is_disjoint function."""
    color = Attribute("color", ['R', 'G', 'B'])
    size = Attribute("size", ['S', 'M', 'L'])
    a = AttributeStructure(color, size)
    o = ['s1', 's2']
    asys = AttributeSystem(a, o)

    ascr = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['B', 'G'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['L', 'S']
    }

    s1 = State(asys, ascr)

    s3 = State(asys, ascr)

    length = Attribute("length", [1, 3, 5])
    shape = Attribute("shape", ['circle', 'triangle', 'rectangle'])
    a = AttributeStructure(length, shape)
    o = ['s1', 's2']
    asys = AttributeSystem(a, o)

    ascr = {
        ('length', 's1'): [5],
        ('length', 's2'): [1, 3],
        ('shape', 's1'): ['circle'],
        ('shape', 's2'): ['triangle', 'rectangle']
    }

    s2 = State(asys, ascr)

    assert s1.is_disjoint(s2)
    assert not s1.is_disjoint(s1)
    assert not s1.is_disjoint(s3)
Example #18
0
def test_get_power():
    """Test get_power(); power = n * |A|."""
    a = Attribute("a", [])
    b = Attribute("b", [])
    R1 = Relation("R1(a) <=> ", ["a"], 1)
    R2 = Relation("R2(a) <=> ", ["b"], 2)

    astr_a_b = AttributeStructure(a, b)
    astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
    objs = ['a', 'b', 'c']

    asys_a_b_o = AttributeSystem(astr_a_b, objs)
    asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)
    # Test when power = 0
    assert AttributeSystem(AttributeStructure(), []).get_power() == 0
    assert AttributeSystem(AttributeStructure(a), []).get_power() == 0
    assert AttributeSystem(AttributeStructure(), ['o1']).get_power() == 0
    # test normal power calculation
    assert asys_a_b_o.get_power() == 6
    assert asys_a_b_R1_R2_o.get_power() == 6
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___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
Example #21
0
def test_add_object():
    """Test add object function to state."""
    def test_TypeError(state, obj, ascriptions=None):
        """Test constructor for TypeErrors with given params."""
        with pytest.raises(TypeError) as excinfo:
            state.add_object(obj, ascriptions)

    def test_ValueError(state, obj, ascriptions=None):
        """Test constructor for ValueErrors with given params."""
        with pytest.raises(ValueError) as excinfo:
            state.add_object(obj, ascriptions)

    color = Attribute("color", ['R', 'G', 'B'])
    a = AttributeStructure(color)
    o = ['s1']
    asys = AttributeSystem(a, o)

    s = State(asys)

    test_TypeError(s, None)
    test_TypeError(s, 1)
    test_TypeError(s, object)
    test_TypeError(s, "")
    test_TypeError(s, "a", 1)
    test_TypeError(s, "a", object)
    test_ValueError(s, "s1")
    test_ValueError(s, "a", {"s1": 1})
    test_ValueError(s, "a", {("s1"): 1})
    test_ValueError(s, "a", {("s1", 's1', 's1'): 1})
    test_ValueError(s, "a", {("color", "s1"): 1})
    test_ValueError(s, "a", {("s", "a"): 1})

    s.add_object("a")
    ascr = {
        ("color", "s1"): ValueSet(['R', 'G', 'B']),
        ("color", "a"): ValueSet(['R', 'G', 'B'])
    }
    assert s._ascriptions == ascr

    s = State(asys)
    s.add_object("a", {("color", "a"): ['R']})
    ascr = {
        ("color", "s1"): ValueSet(['R', 'G', 'B']),
        ("color", "a"): ValueSet(['R'])
    }
    assert s._ascriptions == ascr
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'"]
Example #24
0
def test___deepcopy__():
    """Test copy.deepcopy for AttributeSystem."""
    a = Attribute("a", [])
    b = Attribute("b", [])
    c = Attribute("c", ['a'])
    R1 = Relation("R1(a) <=> ", ["a"], 1)
    R2 = Relation("R2(a) <=> ", ["b"], 2)

    objs = ['a', 'b', 'c']
    astr_a_b_R1_R2 = AttributeStructure(a, b, R1, R2)
    asys_a_b_R1_R2_o = AttributeSystem(astr_a_b_R1_R2, objs)

    import copy
    asys_copy = copy.deepcopy(asys_a_b_R1_R2_o)
    assert asys_copy == asys_a_b_R1_R2_o
    assert asys_copy is not asys_a_b_R1_R2_o
    assert asys_copy._attribute_structure is not \
        asys_a_b_R1_R2_o._attribute_structure
    assert asys_copy._objects is not asys_a_b_R1_R2_o._objects
def test_add_mapping():
    """Test add_mapping function for ConstantAssignment."""
    def test_TypeError(constant_assignment, constant_symbol, obj):
        """Test constructor for TypeErrors with given params."""
        with pytest.raises(TypeError) as excinfo:
            constant_assignment.add_mapping(constant_symbol, obj)

    def test_ValueError(constant_assignment, constant_symbol, obj):
        """Test constructor for ValueErrors with given params."""
        with pytest.raises(ValueError) as excinfo:
            constant_assignment.add_mapping(constant_symbol, obj)

    vocabulary = Vocabulary(['C1', 'C2'], [], [])

    a = Attribute("a", [])
    b = Attribute("b", [])
    astr = AttributeStructure(a, b)
    objs = ['a', 'b', 'c']
    attribute_system = AttributeSystem(astr, objs)

    C = ConstantAssignment(vocabulary, attribute_system, {'C2': 'b'})

    test_TypeError(C, None, 'a')
    test_TypeError(C, object, 'a')
    test_TypeError(C, 'C1', None)
    test_TypeError(C, 'C1', object)
    test_ValueError(C, 'bad_C', 'a')
    test_ValueError(C, 'C1', 'bad_obj')
    test_ValueError(C, 'C2', 'a')
    test_ValueError(C, 'C1', 'b')

    C.add_mapping('C1', 'a')
    C2 = ConstantAssignment(vocabulary, attribute_system, {
        'C2': 'b',
        'C1': 'a'
    })
    C3 = ConstantAssignment(vocabulary, attribute_system, {
        'C1': 'a',
        'C2': 'b'
    })
    assert C == C2
    assert C == C3
Example #26
0
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_in_conflict():
    """Test in_conflict 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'}
    mapping3 = {'C': 'b'}

    CA = ConstantAssignment(vocabulary, attribute_system, mapping)
    CA2 = ConstantAssignment(vocabulary, attribute_system, mapping2)
    CA3 = ConstantAssignment(vocabulary, attribute_system, mapping3)

    assert not CA.in_conflict(CA)
    assert not CA.in_conflict(CA2)
    assert CA.in_conflict(CA3)
Example #29
0
def test_is_world():
    """Test is_world function."""
    color = Attribute("color", ['R', 'G', 'B'])
    size = Attribute("size", ['S', 'M', 'L'])
    a = AttributeStructure(color, size)
    o = ['s1', 's2']
    asys = AttributeSystem(a, o)

    ascr = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['B', 'G'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['L', 'S']
    }

    s = State(asys, ascr)

    assert not s.is_world()
    s.set_ascription(('color', 's2'), ['B'])
    s.set_ascription(('size', 's2'), ['L'])
    assert s.is_world()
def test___deepcopy__():
    """Test copy.deepcopy for VariableAssignment object."""
    from copy import deepcopy

    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)

    VA_copy = deepcopy(VA)
    assert VA == VA_copy
    assert VA is not VA_copy
    assert VA._vocabulary is VA_copy._vocabulary
    assert VA._attribute_system is not VA_copy._attribute_system
    assert VA._mapping is not VA_copy._mapping
Example #31
0
def test___le__():
    """Test <= operator overloaded for extension."""
    color = Attribute("color", ['R', 'G', 'B'])
    size = Attribute("size", ['S', 'M', 'L'])
    a = AttributeStructure(color, size)
    o = ['s1', 's2']
    asys = AttributeSystem(a, o)

    s = State(asys)

    ascr = {
        ('color', 's1'): ['R'],
        ('color', 's2'): ['B', 'G'],
        ('size', 's1'): ['M'],
        ('size', 's2'): ['L', 'S']
    }

    s1 = State(asys, ascr)

    assert s <= s
    assert s1 <= s
    assert not s <= s1