def test_multiple_select(self):
C2 = MockTemplate('C2', fields=('a', 'b'))
Foo = MockTemplate('Foo')
Bar = MockTemplate('Bar')
P = MockPredicate('P')
Q = MockPredicate('Q')
R = MockPredicate('R')
X1, Y1 = meta.TypeMap({Foo: Bar})
X2, Y2 = meta.TypeMap({P & Q: Foo, P: Bar, Q: Foo})
expr = C2[X1, Foo % X2] % X2
pred_sel, field_sel, field_pred_sel = meta.select_variables(expr)
self.assertIs(pred_sel(expr), X2)
self.assertIs(pred_sel(C2[Bar, Foo % Q] % P), P)
self.assertEqual(pred_sel(expr, swap=R), C2[X1, Foo % X2] % R)
self.assertIs(field_sel(expr), X1)
self.assertIs(field_sel(C2[Bar, Foo]), Bar)
self.assertEqual(field_sel(expr, swap=Foo), C2[Foo, Foo % X2] % X2)
self.assertIs(field_pred_sel(expr), X2)
self.assertIs(field_pred_sel(C2[Bar, Foo % Q] % P), Q)
self.assertEqual(field_pred_sel(expr, swap=R), C2[X1, Foo % R] % X2)
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_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_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_variables(self):
P = MockPredicate('P')
Q = MockPredicate('Q')
R = MockPredicate('R')
S = MockPredicate('S')
X, Y = meta.TypeMap({
P & Q: R & S,
P: R,
Q: S,
})
self.assertEqual(X.members, (P & Q, P, Q))
self.assertEqual(Y.members, (R & S, R, S))
self.assertEqual(X.index, 0)
self.assertEqual(Y.index, 1)
self.assertTrue(X.input)
self.assertTrue(Y.output)
self.assertFalse(X.output)
self.assertFalse(Y.input)
# subtyping
self.assertFalse(S <= X)
self.assertFalse(R <= X)
self.assertLessEqual(P, X)
self.assertLessEqual(Q, X)
self.assertLessEqual(P & Q, X)
self.assertLessEqual(P & S | P & R, X)
def test_select_simple(self):
Foo = MockTemplate('Foo')
Bar = MockTemplate('Bar')
X, Y = meta.TypeMap({Foo: Bar})
sel, = meta.select_variables(X)
self.assertIs(sel(X), X)
self.assertIs(sel(Foo), Foo)
self.assertIs(sel(X, swap=Foo), Foo)
def test_select_inside_field(self):
C2 = MockTemplate('C2', fields=('a', 'b'))
Foo = MockTemplate('Foo')
Bar = MockTemplate('Bar')
X, Y = meta.TypeMap({Foo: Bar})
sel, = meta.select_variables(C2[X, Foo])
self.assertIs(sel(C2[X, Bar]), X)
self.assertIs(sel(C2[Bar, Foo]), Bar)
self.assertEqual(sel(C2[X, Foo], swap=Foo), C2[Foo, Foo])
def test_pickle(self):
Foo = MockTemplate('Foo')
Bar = MockTemplate('Bar')
X, Y = meta.TypeMap({Foo: Bar})
X1, Y1 = pickle.loads(pickle.dumps((X, Y))) # Pickled together
self.assertIs(X1.mapping, Y1.mapping)
self.assertEqual(X1.index, X.index)
self.assertEqual(Y1.index, Y.index)
def test_select_predicate(self):
Foo = MockTemplate('Foo')
Bar = MockTemplate('Bar')
P = MockPredicate('P')
Q = MockPredicate('Q')
X, Y = meta.TypeMap({P & Q: Foo, P: Bar, Q: Foo})
sel, = meta.select_variables(Foo % X)
self.assertIs(sel(Foo % X), X)
self.assertIs(sel(Foo % P), P)
self.assertEqual(sel(Foo % X, swap=Q), Foo % Q)
def test_iter_sorted(self):
P = MockPredicate('P', alphabetize=True)
Q = MockPredicate('Q', alphabetize=True)
Other = MockPredicate('Other')
X, Y = meta.TypeMap({
P & Other: Other, P: P, Q & Other: Other, Q: Q, Other: Other
})
mapping = X.mapping
self.assertEqual(
list(mapping.lifted),
[col.Tuple[P & Other], col.Tuple[P], col.Tuple[Q & Other],
col.Tuple[Q], col.Tuple[Other]])
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_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]))
def test_subtype(self):
P = MockPredicate('P')
Q = MockPredicate('Q')
R = MockPredicate('R')
S = MockPredicate('S')
T, U, Y = meta.TypeMap({
(P & Q, P & Q): R & S,
(P & Q, Q): R & S,
(P, P): R,
(Q, Q): S
})
self.assertLessEqual(P, T)
self.assertLessEqual(Q, T)
self.assertFalse(P | Q <= T)
self.assertLessEqual(T, U)
def test_mismatched_pieces(self):
P = MockPredicate('P')
Bar = MockTemplate('Bar')
with self.assertRaisesRegex(ValueError, 'in the same'):
meta.TypeMap({P: P, Bar: Bar})
def test_missing_branch_requested(self):
P = MockPredicate('P')
Q = MockPredicate('Q')
with self.assertRaisesRegex(ValueError, 'Ambiguous'):
meta.TypeMap({P: P, Q: Q})
