Beispiel #1
0
    def test_identity(self):
        x = grammar.UnionExp()

        self.assertTrue(x.is_bottom())
        self.assertEqual(repr(x), 'UnionExp()')
        self.assertEqual(x.kind, 'identity')
        self.assertEqual(x.name, '')
Beispiel #2
0
    def test_distribution(self):
        C2 = MockTemplate('C2', fields=('a', 'b'))
        Foo = MockTemplate('Foo')
        Bar = MockTemplate('Bar')
        P = MockPredicate('P')
        Q = MockPredicate('Q')
        R = MockPredicate('R')
        S = MockPredicate('S')

        self.assertTrue(
            ((P | Q) & (R | S)).equals(P & R | P & S | Q & R | Q & S))

        self.assertTrue(((P | Q) & (R & S)).equals(P & R & S | Q & R & S))

        self.assertEqual(Foo & Bar, grammar.UnionExp())

        self.assertEqual(C2[Foo, Bar] & C2[Foo, Foo], grammar.UnionExp())

        self.assertTrue(
            (C2[Foo % P, Bar] & C2[Foo % Q, Bar]).equals(C2[Foo % (P & Q),
                                                            Bar]))
Beispiel #3
0
    def test_not_concrete(self):
        Foo = MockTemplate('Foo')
        Bar = MockTemplate('Bar')
        C2 = MockTemplate('C2', fields=('a', 'b'))
        P = MockPredicate('P')
        Q = MockPredicate('Q')
        AnnoyingToMake = grammar.TypeExp(Foo.template,
                                         predicate=grammar.UnionExp((P, Q)))

        self.assertFalse((Foo | Bar).is_concrete())
        self.assertFalse(C2[Foo | Bar, Bar].is_concrete())
        self.assertFalse(C2[Foo, Bar | Foo].is_concrete())
        self.assertFalse(AnnoyingToMake.is_concrete())
Beispiel #4
0
    def test_distribution(self):
        Foo = MockTemplate('Foo')
        Bar = MockTemplate('Bar')
        P = MockPredicate('P')
        Q = MockPredicate('Q')
        R = MockPredicate('R')
        S = MockPredicate('S')

        self.assertTrue(((P | Q) | (R | S)).equals(P | Q | R | S))
        self.assertTrue((P | (Q | R)).equals(P | Q | R))

        self.assertEqual(repr(Foo % P | Bar % Q | Foo % R | Bar % S),
                         'Foo % (P | R) | Bar % (Q | S)')

        self.assertEqual(
            repr(
                grammar.UnionExp([Foo % P, Bar % Q, Foo % R,
                                  Bar % S]).normalize()),
            'Foo % (P | R) | Bar % (Q | S)')
Beispiel #5
0
    def test_repr(self):
        Face0 = MockTemplate('(o_-)')
        Face1 = MockTemplate('-_-')
        Exclaim0 = MockTemplate('!')
        Exclaim1 = MockTemplate('!', fields=('a', ))
        Exclaim2 = MockTemplate('!', fields=('a', 'b'))
        Face2 = MockPredicate('(o_o)')
        Face3 = grammar.IntersectionExp(
            (MockPredicate('='), MockPredicate('=')))  # repr -> "= & ="
        Face4 = grammar.UnionExp((MockPredicate('<'), MockPredicate('<')))

        self.assertEqual(repr(Exclaim0), '!')
        self.assertEqual(repr(Exclaim1[Face1]), '![-_-]')
        self.assertEqual(repr(Exclaim2[Face1, Exclaim0]), '![-_-, !]')
        self.assertEqual(repr(Exclaim2[Face1, Exclaim0] % Face2),
                         '![-_-, !] % (o_o)')
        self.assertEqual(repr(Face0 % Face2), '(o_-) % (o_o)')
        self.assertEqual(repr(Face0 % Face3), '(o_-) % (= & =)')
        self.assertEqual(repr(Exclaim2[Face1, Exclaim0] % Face3),
                         '![-_-, !] % (= & =)')
        self.assertEqual(repr(Exclaim2[Face1, Exclaim0] % Face4),
                         '![-_-, !] % (< | <)')
Beispiel #6
0
    def test_disjoint_exclusive_point(self):
        a = primitive.Range(0, 5, inclusive_end=False)
        b = primitive.Range(5, 9, inclusive_start=False)

        self.assertIntersectEqual(a, b, grammar.UnionExp())
Beispiel #7
0
    def test_disjoint_far(self):
        a = primitive.Range(-10, -5)
        b = primitive.Range(5, 10)

        self.assertIntersectEqual(a, b, grammar.UnionExp())