def test_that_python_constraints_dont_spread_to_constrained_children(self):
bar = PythonObject({
"baz": 42
})
foo = PythonObject({
"bar": bar
})
# The first, stronger, type prevents the NO_SETTER_ERROR_COMPOSITE_TYPE spreading from foo to bar
get_manager(bar).add_composite_type(UniversalObjectType({ "baz": IntegerType() }))
get_manager(foo).add_composite_type(NO_SETTER_ERROR_COMPOSITE_TYPE)
self.assertIs(foo.bar, bar)
self.assertEquals(len(get_manager(foo).attached_types), 1)
self.assertEquals(len(get_manager(foo.bar).attached_types), 1)
# ... but when bar is replaced with a new object without constraints, the PythonObjectType
# spreads to the new object
foo.bar = PythonObject({
"baz": 123
})
self.assertIsNot(foo.bar, bar)
self.assertEquals(len(get_manager(foo.bar).attached_types), 1)
# Now that the new object has the PythonObjectType constraint, we can't bind a stronger
# constraint
with self.assertRaises(CompositeTypeIncompatibleWithTarget):
get_manager(foo.bar).add_composite_type(UniversalObjectType({ "baz": IntegerType() }))
def test_basic_tuple_of_ints(self):
foo = PythonList([ 1, 2, 3 ])
get_manager(foo).add_composite_type(UniversalTupleType([ IntegerType(), IntegerType(), IntegerType() ]))
foo[0] = 42
self.assertEqual(foo[0], 42)
def test_misc2(self):
# Came up writing test_misc1
PythonObject({
"local": PythonList([ 39, 3 ])
}, bind=UniversalObjectType({
"local": UniversalTupleType([ IntegerType(), IntegerType() ])
}, wildcard_type=RICH_READONLY_TYPE))
def test_rev_const_merge_types_in_list(self):
rev_const_type = CompositeType({
("get", 0): GetterMicroOpType(0, StringType()),
("set", 0): SetterMicroOpType(0, StringType()),
("get", 1): GetterMicroOpType(1, IntegerType()),
("set", 1): SetterMicroOpType(1, IntegerType()),
("get", 2): GetterMicroOpType(2, AnyType()),
("set", 2): SetterMicroOpType(2, AnyType()),
("insert-start", ): InsertStartMicroOpType(StringType(), False)
}, name="test")
normal_broad_type = CompositeType({
("get", 0): GetterMicroOpType(0, StringType()),
("set", 0): SetterMicroOpType(0, StringType()),
("get", 1): GetterMicroOpType(1, IntegerType()),
("set", 1): SetterMicroOpType(1, IntegerType()),
("get", 2): GetterMicroOpType(2, AnyType()),
("set", 2): SetterMicroOpType(2, AnyType()),
}, name="test")
self.assertFalse(rev_const_type.is_self_consistent(DUMMY_REASONER))
rev_const_type = prepare_lhs_type(rev_const_type, None)
self.assertTrue(rev_const_type.is_self_consistent(DUMMY_REASONER))
self.assertTrue(normal_broad_type.is_copyable_from(rev_const_type, DUMMY_REASONER))
def test_misc1(self):
# Came up testing lockdown local variable binding
PythonObject({
"local": PythonList([ 39, 3 ]),
"types": PythonObject({})
}, bind=UniversalObjectType({
"local": UniversalTupleType([ IntegerType(), IntegerType() ]),
"types": DEFAULT_READONLY_COMPOSITE_TYPE
}, wildcard_type=RICH_READONLY_TYPE))
def test_insert_on_long_tuple(self):
foo = PythonList([ 4, 6, 8 ])
get_manager(foo).add_composite_type(
UniversalLupleType(
[ IntegerType(), IntegerType() ],
IntegerType()
)
)
foo.insert(0, 2)
self.assertEqual(list(foo), [ 2, 4, 6, 8 ])
def test_basic_class(self):
T = UniversalObjectType({
"foo": IntegerType()
})
S = UniversalObjectType({
"foo": IntegerType(),
"bar": StringType()
})
self.assertTrue(T.is_copyable_from(S, DUMMY_REASONER))
self.assertFalse(S.is_copyable_from(T, DUMMY_REASONER))
def test_many_fields_are_required(self):
T = UniversalObjectType({
"foo": IntegerType(),
"bar": IntegerType(),
})
S = UniversalObjectType({
"foo": IntegerType(),
"bar": IntegerType(),
"baz": IntegerType()
})
self.assertTrue(T.is_copyable_from(S, DUMMY_REASONER))
self.assertFalse(S.is_copyable_from(T, DUMMY_REASONER))
def test_merge_gets(self):
first = GetterMicroOpType("foo", IntegerType())
second = GetterMicroOpType("foo", UnitType(5))
combined = first.merge(second)
self.assertTrue(isinstance(combined.value_type, UnitType))
self.assertEqual(combined.value_type.value, 5)
def test_modifying(self):
At = UniversalObjectType({
"foo": IntegerType()
})
Bt = UniversalObjectType({
"bar": At
})
A = PythonObject({
"foo": 5
})
B = PythonObject({
"bar": A
}, bind=Bt)
self.assertEquals(len(get_manager(A).attached_types), 1)
self.assertEquals(get_manager(A).attached_type_counts[id(At)], 1)
B.bar = PythonObject({
"foo": 42
}, bind=At)
self.assertEquals(len(get_manager(A).attached_types), 0)
self.assertEquals(get_manager(A).attached_type_counts[id(At)], 0)
def test_adding_and_removing(self):
A = PythonObject({
"foo": 5
})
B = PythonObject({
"bar": A
})
At = UniversalObjectType({
"foo": IntegerType()
})
Bt = UniversalObjectType({
"bar": At
})
get_manager(A).add_composite_type(At)
self.assertEquals(len(get_manager(A).attached_types), 1)
self.assertEquals(get_manager(A).attached_type_counts[id(At)], 1)
get_manager(B).add_composite_type(Bt)
self.assertEquals(len(get_manager(A).attached_types), 1)
self.assertEquals(get_manager(A).attached_type_counts[id(At)], 2)
get_manager(B).remove_composite_type(Bt)
self.assertEquals(len(get_manager(A).attached_types), 1)
self.assertEquals(get_manager(A).attached_type_counts[id(At)], 1)
def test_interesting(self):
func = function_lit(
any_type(), infer_all(),
match_op(dereference("argument"), [
prepared_function(
object_type({"foo": int_type()}),
return_op(
addition_op(dereference("argument.foo"),
literal_op(3)))),
prepared_function(any_type(), return_op(literal_op("invalid")))
]))
_, result = bootstrap_function(func,
argument=PythonObject(
{"foo": 39},
bind=UniversalObjectType(
{"foo": IntegerType()})))
self.assertEquals(result.caught_break_mode, "return")
self.assertEquals(result.value, 42)
_, result = bootstrap_function(func,
argument=PythonObject({"foo": "hello"}))
self.assertEquals(result.caught_break_mode, "return")
self.assertEquals(result.value, "invalid")
def test_basic_list_of_ints(self):
foo = PythonList([ 1, 2, 3 ])
get_manager(foo).add_composite_type(UniversalListType(IntegerType()))
foo[0] = 42
self.assertEqual(foo[0], 42)
def test_double_deep_assignment(self):
foo = PythonObject({
"bar": PythonObject({
"baz": PythonObject({
"bam": 10
})
})
})
Baz = UniversalObjectType({
"bam": IntegerType()
})
Bar = UniversalObjectType({
"baz": Baz
})
get_manager(foo).add_composite_type(
UniversalObjectType({
"bar": Bar
})
)
self.assertEquals(foo.bar.baz.bam, 10)
foo.bar = PythonObject({ "baz": PythonObject({ "bam": 42 }) }, bind=Bar)
self.assertEquals(foo.bar.baz.bam, 42)
def test_outside_tuple_access_blocked(self):
foo = PythonList([ 4, 6, 8 ])
get_manager(foo).add_composite_type(UniversalTupleType([ IntegerType(), AnyType() ]))
with self.assertRaises(IndexError):
foo[2]
with self.assertRaises(IndexError):
foo[2] = "hello"
def test_basic_ignored(self):
foo = UniversalObjectType({
"bar": StringType()
})
foo = prepare_lhs_type(foo, UniversalObjectType({
"bar": IntegerType()
}))
self.assertIsInstance(foo.get_micro_op_type(("get", "bar")).value_type, StringType)
def test_types_on_object_merged(self):
foo = PythonObject({
"foo": 5,
"bar": "hello"
})
get_manager(foo).add_composite_type(
UniversalObjectType({ "foo": IntegerType() })
)
get_manager(foo).add_composite_type(
UniversalObjectType({ "bar": StringType() })
)
object_type = get_manager(foo).get_effective_composite_type()
UniversalObjectType({
"foo": IntegerType(),
"bar": StringType()
}).is_copyable_from(object_type, DUMMY_REASONER)
def test_runtime(self):
obj = PythonObject({
"foo": 5
})
get_manager(obj).add_composite_type(
UniversalObjectType({
"foo": OneOfType([ IntegerType(), StringType() ])
})
)
def test_composite_types_inferred(self):
foo = UniversalObjectType({
"bar": InferredType()
})
foo = prepare_lhs_type(foo, UniversalObjectType({
"bar": UniversalObjectType({
"bam": IntegerType()
})
}))
self.assertIsInstance(foo.get_micro_op_type(("get", "bar")).value_type.get_micro_op_type(("get", "bam")).value_type, IntegerType)
def test_mixed_type_tuple(self):
foo = PythonList([ 4, 6, 8 ])
get_manager(foo).add_composite_type(UniversalTupleType([ IntegerType(), AnyType() ]))
with self.assertRaises(TypeError):
foo[0] = "hello"
self.assertEqual(foo[0], 4)
foo[1] = "what"
self.assertEqual(foo[1], "what")
def test_broad_type_assignments_blocked(self):
T = UniversalObjectType({
"foo": AnyType()
})
S = UniversalObjectType({
"foo": IntegerType()
})
self.assertFalse(T.is_copyable_from(S, DUMMY_REASONER))
self.assertFalse(S.is_copyable_from(T, DUMMY_REASONER))
def test_const_allows_broader_types(self):
T = UniversalObjectType({
"foo": Const(AnyType())
})
S = UniversalObjectType({
"foo": IntegerType()
})
self.assertTrue(T.is_copyable_from(S, DUMMY_REASONER))
self.assertFalse(S.is_copyable_from(T, DUMMY_REASONER))
def test_broadening_with_const_is_ok(self):
foo = PythonObject({
"bar": 42
})
get_manager(foo).add_composite_type(UniversalObjectType({
"bar": UnitType(42)
}))
get_manager(foo).add_composite_type(UniversalObjectType({
"bar": Const(IntegerType())
}))
def test_narrowing_blocked(self):
foo = PythonObject({
"bar": 42
})
get_manager(foo).add_composite_type(UniversalObjectType({
"bar": IntegerType()
}))
with self.assertRaises(CompositeTypeIncompatibleWithTarget):
get_manager(foo).add_composite_type(UniversalObjectType({
"bar": UnitType(42)
}))
def test_can_fail_micro_ops_are_enforced(self):
foo = PythonObject({
"foo": 5,
"bar": "hello"
})
get_manager(foo).add_composite_type(
UniversalObjectType({ "foo": Const(IntegerType()) })
)
with self.assertRaises(Exception):
foo.foo = "hello"
def test_merge_irrelevant_types(self):
self.assertTrue(isinstance(merge_types([ StringType(), StringType(), IntegerType() ], "super"), OneOfType))
self.assertTrue(len(merge_types([ StringType(), StringType(), IntegerType() ], "super").types) == 2)
self.assertTrue(isinstance(merge_types([ StringType(), StringType(), IntegerType() ], "sub"), OneOfType))
self.assertTrue(len(merge_types([ StringType(), StringType(), IntegerType() ], "sub").types) == 2)
self.assertTrue(isinstance(merge_types([ StringType(), StringType(), IntegerType() ], "exact"), OneOfType))
self.assertTrue(len(merge_types([ StringType(), IntegerType() ], "exact").types) == 2)
def test_nested(self):
self.assertTrue(
UniversalObjectType({
"foo": OneOfType([ IntegerType(), StringType() ])
}).is_copyable_from(UniversalObjectType({
"foo": OneOfType([ IntegerType(), StringType() ])
}), DUMMY_REASONER)
)
# Blocked because the receiver could set obj.foo = "hello", breaking the sender
self.assertFalse(
UniversalObjectType({
"foo": OneOfType([ IntegerType(), StringType() ])
}).is_copyable_from(UniversalObjectType({
"foo": IntegerType()
}), DUMMY_REASONER)
)
self.assertTrue(
UniversalObjectType({
"foo": Const(OneOfType([ IntegerType(), StringType() ]))
}).is_copyable_from(UniversalObjectType({
"foo": IntegerType()
}), DUMMY_REASONER)
)
def test_merge_pairwise_unrelated_types(self):
self.assertTrue(isinstance(merge_types([ StringType(), IntegerType() ], "super"), OneOfType))
self.assertTrue(len(merge_types([ StringType(), IntegerType() ], "super").types) == 2)
self.assertTrue(isinstance(merge_types([ StringType(), IntegerType() ], "sub"), OneOfType))
self.assertTrue(len(merge_types([ StringType(), IntegerType() ], "sub").types) == 2)
self.assertTrue(isinstance(merge_types([ StringType(), IntegerType() ], "exact"), OneOfType))
self.assertTrue(len(merge_types([ StringType(), IntegerType() ], "exact").types) == 2)
def test_python_object_with_reference_types_are_enforced(self):
bar = PythonObject({
"baz": 42
})
foo = PythonObject({
"bar": bar
})
get_manager(bar).add_composite_type(UniversalObjectType({ "baz": IntegerType() }))
get_manager(foo).add_composite_type(DEFAULT_COMPOSITE_TYPE)
with self.assertRaises(Exception):
foo.bar.baz = "hello"
def test_const_is_enforced(self):
return # test doesn't work because the assignment uses the set-wildcard
foo = {
"foo": 5,
"bar": "hello"
}
get_manager(foo).add_composite_type(
UniversalObjectType({ "foo": Const(IntegerType()) })
)
with self.assertRaises(Exception):
foo.foo = 42
