def test_multiple_mappings(self): C2 = MockTemplate('C2', fields=('a', 'b')) Foo = MockTemplate('Foo') Bar = MockTemplate('Bar') P = MockPredicate('P') X, Y = meta.TypeMap({ Foo % P: Foo, Bar % P: Foo % P, Foo: Bar, Bar: Bar % P }) T, R = meta.TypeMap({ Bar % P: Foo, Foo % P: Foo % P, Bar: Bar, Foo: Bar % P }) input_signature = dict(input1=C2[X, T]) output_signature = dict(output1=C2[R, Y]) foop = dict(input1=C2[Foo % P, Bar]) barp = dict(input1=C2[Bar % P, Bar % P]) foo = dict(input1=C2[Foo, Foo]) bar = dict(input1=C2[Bar, Foo]) self.assertEqual(meta.match(foop, input_signature, output_signature), dict(output1=C2[Bar, Foo])) self.assertEqual(meta.match(barp, input_signature, output_signature), dict(output1=C2[Foo, Foo % P])) self.assertEqual(meta.match(foo, input_signature, output_signature), dict(output1=C2[Bar % P, Bar])) self.assertEqual(meta.match(bar, input_signature, output_signature), dict(output1=C2[Bar % P, Bar % P]))
def test_type_match_auto_intersect(self): C1 = MockTemplate('C1', fields=('a', )) Foo = MockTemplate('Foo') P = MockPredicate('P') Q = MockPredicate('Q') R = MockPredicate('R') S = MockPredicate('S') T = meta.TypeMatch([P, Q, R, S]) input_signature = dict(input1=C1[Foo] % T) output_signature = dict(output1=Foo % T) pqrs = dict(input1=C1[Foo] % (P & Q & R & S)) p = dict(input1=C1[Foo] % P) pr = dict(input1=C1[Foo] % (P & R)) qs = dict(input1=C1[Foo] % (Q & S)) self.assertEqual(meta.match(pqrs, input_signature, output_signature), dict(output1=Foo % (P & Q & R & S))) self.assertEqual(meta.match(p, input_signature, output_signature), dict(output1=Foo % P)) self.assertEqual(meta.match(pr, input_signature, output_signature), dict(output1=Foo % (P & R))) self.assertEqual(meta.match(qs, input_signature, output_signature), dict(output1=Foo % (Q & S)))
def test_multiple_variables(self): C2 = MockTemplate('C2', fields=('a', 'b')) Foo = MockTemplate('Foo') Bar = MockTemplate('Bar') P = MockPredicate('P') A, B, C, Y, Z = meta.TypeMap({ (Foo % P, Bar, Bar): (Foo, Foo), (Foo, Bar % P, Foo): (Bar, Foo), (Foo, Foo, Bar): (Foo, Bar), (Bar, Bar % P, Foo): (Bar, Bar) }) input_signature = dict(input1=C2[A, B], input2=C) output_signature = dict(output1=C2[Y, Z]) fbb = dict(input1=C2[Foo % P, Bar], input2=Bar) fbf = dict(input1=C2[Foo, Bar % P], input2=Foo) ffb = dict(input1=C2[Foo, Foo], input2=Bar % P) # subtype on in2! bbf = dict(input1=C2[Bar % P, Bar % P], input2=Foo) # subtype on in1 self.assertEqual(meta.match(fbb, input_signature, output_signature), dict(output1=C2[Foo, Foo])) self.assertEqual(meta.match(fbf, input_signature, output_signature), dict(output1=C2[Bar, Foo])) self.assertEqual(meta.match(ffb, input_signature, output_signature), dict(output1=C2[Foo, Bar])) self.assertEqual(meta.match(bbf, input_signature, output_signature), dict(output1=C2[Bar, Bar]))
def test_single_variable(self): Foo = MockTemplate('Foo') Bar = MockTemplate('Bar') P = MockPredicate('P') X, Y = meta.TypeMap({ Foo % P: Foo, Bar % P: Foo % P, Foo: Bar, Bar: Bar % P }) input_signature = dict(input1=X) output_signature = dict(output1=Y) foop = dict(input1=Foo % P) barp = dict(input1=Bar % P) foo = dict(input1=Foo) bar = dict(input1=Bar) self.assertEqual(meta.match(foop, input_signature, output_signature), dict(output1=Foo)) self.assertEqual(meta.match(barp, input_signature, output_signature), dict(output1=Foo % P)) self.assertEqual(meta.match(foo, input_signature, output_signature), dict(output1=Bar)) self.assertEqual(meta.match(bar, input_signature, output_signature), dict(output1=Bar % P))
def test_missing_variables(self): C2 = MockTemplate('C2', fields=('a', 'b')) Foo = MockTemplate('Foo') Bar = MockTemplate('Bar') P = MockPredicate('P') A, B, C, Y, Z = meta.TypeMap({ (Foo % P, Bar, Bar): (Foo, Foo), (Foo, Bar % P, Foo): (Bar, Foo), (Foo, Foo, Bar): (Foo, Bar), (Bar, Bar % P, Foo): (Bar, Bar) }) input_signature = dict(input1=C2[A, B], input2=Foo) output_signature = dict(output1=C2[Y, Z]) with self.assertRaisesRegex(ValueError, 'Missing'): meta.match(dict(input1=C2[Foo, Foo], input2=Foo), input_signature, output_signature)
def test_inconsistent_binding(self): C2 = MockTemplate('C2', fields=('a', 'b')) Foo = MockTemplate('Foo') Bar = MockTemplate('Bar') P = MockPredicate('P') A, B, C, Y, Z = meta.TypeMap({ (Foo % P, Bar, Bar): (Foo, Foo), (Foo, Bar % P, Foo): (Bar, Foo), (Foo, Foo, Bar): (Foo, Bar), (Bar, Bar % P, Foo): (Bar, Bar) }) input_signature = dict(input1=C2[A, B], input2=C2[C, C]) output_signature = dict(output1=C2[Y, Z]) with self.assertRaisesRegex(ValueError, 'to match'): meta.match(dict(input1=C2[Foo, Bar % P], input2=C2[Foo, Bar]), input_signature, output_signature)
def test_no_variables(self): Foo = MockTemplate('Foo') Bar = MockTemplate('Bar') P = MockPredicate('P') input_signature = dict(input1=Foo, input2=Bar) output_signature = dict(output1=Bar % P, output2=Foo % P) given = dict(input1=Foo % P, input2=Bar) self.assertEqual(meta.match(given, input_signature, output_signature), output_signature)
def test_type_match(self): Foo = MockTemplate('Foo') Bar = MockTemplate('Bar') Baz = MockTemplate('Baz') P = MockPredicate('P') T = meta.TypeMatch([Baz, Foo, Bar]) input_signature = dict(input1=T) output_signature = dict(output1=T) foop = dict(input1=Foo % P) barp = dict(input1=Bar % P) foo = dict(input1=Foo) bar = dict(input1=Bar) self.assertEqual(meta.match(foop, input_signature, output_signature), dict(output1=Foo)) self.assertEqual(meta.match(barp, input_signature, output_signature), dict(output1=Bar)) self.assertEqual(meta.match(foo, input_signature, output_signature), dict(output1=Foo)) self.assertEqual(meta.match(bar, input_signature, output_signature), dict(output1=Bar))
def test_consistent_subtype_binding(self): C2 = MockTemplate('C2', fields=('a', 'b')) Foo = MockTemplate('Foo') Bar = MockTemplate('Bar') P = MockPredicate('P') A, B, C, Y, Z = meta.TypeMap({ (Foo % P, Bar, Bar): (Foo, Foo), (Foo, Bar % P, Foo): (Bar, Foo), (Foo, Foo, Bar): (Foo, Bar), (Bar, Bar % P, Foo): (Bar, Bar) }) input_signature = dict(input1=C2[A, B], input2=C2[C, C]) output_signature = dict(output1=C2[Y, Z]) cons = dict(input1=C2[Foo, Bar % P], input2=C2[Foo, Foo % P]) self.assertEqual(meta.match(cons, input_signature, output_signature), dict(output1=C2[Bar, Foo]))