def test_count_then_return(self): _, result = bootstrap_function( function_lit( no_value_type(), build_break_types(int_type()), int_type(), literal_op(0), loop_op( comma_op( assignment_op( context_op(), literal_op("local"), addition_op( dereference_op(context_op(), literal_op("local"), True), literal_op(1))), condition_op( equality_op( dereference_op(context_op(), literal_op("local"), True), literal_op(42)), return_op( dereference_op(context_op(), literal_op("local"))), nop()))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_restart_into_local_initialization(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(any_type(), yield_types={ "out": any_type(), "in": int_type() }), int_type(), shift_op(literal_op("hello"), int_type()), return_op( dereference_op(context_op(), literal_op("local"), True))), context, frame_manager).close(None) def start(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as yielder: start() self.assertEquals(yielder.value, "hello") def restart(): yielder_restart_continuation = yielder.create_continuation( start, func.get_type().break_types) yielder_restart_continuation.invoke(32, frame_manager) with frame_manager.capture("return") as returner: restart() self.assertEquals(returner.value, 32)
def test_infer_all(self): _, result = bootstrap_function( function_lit(no_value_type(), infer_all(), return_op(literal_op(42)))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_to_string_from_int(self): func = function_lit( any_type(), return_op( match_op(dereference("argument"), [ prepared_function(unit_type(1), literal_op("one")), prepared_function(unit_type(2), literal_op("two")), prepared_function(unit_type(3), literal_op("three")), prepared_function(unit_type(4), literal_op("four")), prepared_function(any_type(), literal_op("invalid")) ]))) _, result = bootstrap_function(func, argument=1) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "one") _, result = bootstrap_function(func, argument=2) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "two") _, result = bootstrap_function(func, argument=3) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "three") _, result = bootstrap_function(func, argument=4) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "four") _, result = bootstrap_function(func, argument=5) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "invalid")
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_return_with_dereference4(self): _, result = bootstrap_function(function_lit( int_type(), build_break_types( object_type({ "foo": any_type(), "bar": any_type() })), comma_op( return_op( object_template_op({ "foo": literal_op(42), "bar": dereference_op(context_op(), literal_op("argument"), True) })))), argument=42, check_safe_exit=True) self.assertEquals(result.caught_break_mode, "return") self.assertTrue(isinstance(result.value, Universal)) get_manager( result.value).add_composite_type(DEFAULT_READONLY_COMPOSITE_TYPE) self.assertEquals(result.value._get("foo"), 42) self.assertEquals(result.value._get("bar"), 42)
def test_to_match_with_one_of_type_combo(self): func = function_lit( one_of_type([string_type(), int_type(), bool_type()]), return_op( match_op(dereference("argument"), [ prepared_function(int_type(), literal_op("int is not a string")), prepared_function(bool_type(), literal_op("bool is not a string")), prepared_function(inferred_type(), dereference("argument")) ]))) _, result = bootstrap_function(func, argument=2) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "int is not a string") _, result = bootstrap_function(func, argument=True) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "bool is not a string") _, result = bootstrap_function(func, argument="hello world") self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "hello world") prepared_func = prepare(func, PythonObject({}), FrameManager()) self.assertEquals(len(prepared_func.break_types), 1) self.assertTrue("return" in prepared_func.break_types) for return_break_type in prepared_func.break_types["return"]: self.assertTrue(StringType().is_copyable_from( return_break_type["out"], DUMMY_REASONER))
def test_single_restart(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(any_type(), yield_types={ "out": any_type(), "in": int_type() }), return_op( addition_op(shift_op(literal_op("hello"), int_type()), literal_op(40)))), context, frame_manager).close(None) def first(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as yielder: first() self.assertEquals(yielder.value, "hello") def second(): yielder.create_continuation(first, {}).invoke(2, frame_manager) with frame_manager.capture("return") as returner: second() self.assertEquals(returner.value, 42)
def test_immediate_return(self): _, result = bootstrap_function( function_lit(no_value_type(), build_break_types(int_type()), loop_op(return_op(literal_op(42))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_basic_inferrence(self): _, result = bootstrap_function( function_lit(no_value_type(), build_break_types(inferred_type()), return_op(literal_op(42)))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_comma(self): _, result = bootstrap_function(function_lit( no_value_type(), build_break_types(int_type()), return_op(comma_op(literal_op(5), literal_op(8), literal_op(42)))), check_safe_exit=True) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_static_value_dereference(self): _, result = bootstrap_function( function_lit( return_op(static_op(addition_op(literal_op(5), literal_op(37)))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_infer_exception(self): _, result = bootstrap_function(function_lit( no_value_type(), infer_all(), addition_op(literal_op("hello"), literal_op(5))), check_safe_exit=False) self.assertEquals(result.caught_break_mode, "exception") self.assertEquals(result.value.type, "TypeError")
def test_basic_with_inferred_local_type(self): _, result = bootstrap_function( function_lit( no_value_type(), infer_all(), inferred_type(), close_op( static_op( prepare_op( literal_op( function_lit(no_value_type(), infer_all(), return_op(literal_op(42)))))), context_op()), return_op( invoke_op( dereference_op(context_op(), literal_op("local"), True))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_basic(self): _, result = bootstrap_function( function_lit( no_value_type(), build_break_types(int_type()), return_op( invoke_op( close_op( static_op( prepare_op( literal_op( function_lit( no_value_type(), build_break_types(int_type()), return_op(literal_op(42)))))), context_op()))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_basic_function(self): func = function_lit(no_value_type(), build_break_types(value_type=int_type()), literal_op(42)) _, result = bootstrap_function(func) self.assertEquals(result.caught_break_mode, "value") self.assertEquals(result.value, 42)
def test_addition(self): func = function_lit( no_value_type(), build_break_types(int_type()), return_op(addition_op(literal_op(40), literal_op(2)))) _, result = bootstrap_function(func) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_basic_false(self): _, result = bootstrap_function( function_lit( no_value_type(), build_break_types(int_type()), return_op( condition_op(literal_op(False), literal_op(34), literal_op(53))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 53)
def test_simple_return_argument(self): func = function_lit( int_type(), build_break_types(int_type()), return_op( dereference_op(context_op(), literal_op("argument"), True))) _, result = bootstrap_function(func, argument=42) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_initialization(self): _, result = bootstrap_function(function_lit( no_value_type(), build_break_types(int_type()), int_type(), literal_op(42), comma_op( return_op( dereference_op(context_op(), literal_op("local"), True)))), check_safe_exit=True) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_unbound_reference_to_locals_and_arguments(self): _, result = bootstrap_function(function_lit( object_type({"foo": int_type()}), infer_all(), object_type({"bar": int_type()}), object_template_op({"bar": literal_op(3)}), return_op( addition_op(unbound_dereference("foo"), unbound_dereference("bar")))), argument=PythonObject({"foo": 39})) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_return(self): _, result = bootstrap_function(function_lit( no_value_type(), build_break_types(object_type({"foo": int_type()})), comma_op(return_op(object_template_op({"foo": literal_op(42)})))), check_safe_exit=True) self.assertEquals(result.caught_break_mode, "return") self.assertTrue(isinstance(result.value, Universal)) get_manager( result.value).add_composite_type(DEFAULT_READONLY_COMPOSITE_TYPE) self.assertEquals(result.value._get("foo"), 42)
def build_executor(raw_code): return function_lit( transform_op( "yield", "read", reset_op( close_op( static_op( prepare_op( literal_op( parse(raw_code, post_chain_function=CodeBlockBuilder( [build_looper()]))))), context_op()), nop())))
def test_catch_real_exception(self): # Function safely handles an internal exception func = function_lit( try_catch_op( dereference_op(context_op(), literal_op("foo"), True), prepared_function( object_type({ "type": const_string_type(), "message": const_string_type(), }), return_op(dereference("argument.message"))), nop())) _, result = bootstrap_function(func) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, "DereferenceOp: invalid_dereference")
def test_assignment_from_argument(self): _, result = bootstrap_function(function_lit( int_type(), build_break_types(int_type()), int_type(), literal_op(0), comma_op( assignment_op( context_op(), literal_op("local"), dereference_op(context_op(), literal_op("argument"), True)), return_op( dereference_op(context_op(), literal_op("local"), True)))), argument=43, check_safe_exit=True) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 43)
def test_restart_comma(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(int_type(), yield_types={ "out": any_type(), "in": int_type() }), return_op( comma_op(literal_op(5), shift_op(literal_op("first"), int_type()), shift_op(literal_op("second"), int_type())))), context, frame_manager).close(None) def first(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as first_yielder: first() self.assertEquals(first_yielder.value, "first") def second(): first_yield_restart_continuation = first_yielder.create_continuation( first, func.get_type().break_types) first_yield_restart_continuation.invoke(4, frame_manager) with frame_manager.capture("yield") as second_yielder: second() self.assertEquals(second_yielder.value, "second") def third(): second_yield_restart_continuation = second_yielder.create_continuation( second, func.get_type().break_types) second_yield_restart_continuation.invoke(42, frame_manager) with frame_manager.capture("return") as returner: third() self.assertEquals(returner.value, 42)
def test_misc1(self): _, result = bootstrap_function( function_lit( no_value_type(), infer_all(), object_type({ "foo": int_type(), "bar": int_type() }), object_template_op({ "foo": literal_op(39), "bar": literal_op(3) }), return_op( addition_op(dereference("local.foo"), dereference("local.bar"))))) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)
def test_restart_into_local_initialization_and_code(self): context = PythonObject({}) frame_manager = FrameManager() func = prepare( function_lit( no_value_type(), build_break_types(any_type(), yield_types={ "out": any_type(), "in": int_type() }), int_type(), shift_op(literal_op("first"), int_type()), return_op( addition_op( dereference_op(context_op(), literal_op("local"), True), shift_op(literal_op("second"), int_type())))), context, frame_manager).close(None) def first(): func.invoke(NO_VALUE, frame_manager) with frame_manager.capture("yield") as first_yielder: first() self.assertEquals(first_yielder.value, "first") def second(): first_restart_continuation = first_yielder.create_continuation( first, func.get_type().break_types) first_restart_continuation.invoke(40, frame_manager) with frame_manager.capture("yield") as second_yielder: second() self.assertEquals(second_yielder.value, "second") with frame_manager.capture("return") as returner: second_restart_continuation = second_yielder.create_continuation( first, func.get_type().break_types) second_restart_continuation.invoke(2, frame_manager) self.assertEquals(returner.value, 42)
def test_return_with_dereference5(self): with self.assertRaises(Exception): bootstrap_function(function_lit( int_type(), build_break_types( object_type({ "foo": any_type(), "bar": unit_type(42) })), return_op( object_template_op({ "foo": literal_op(42), "bar": dereference_op(context_op(), literal_op("argument"), True) }))), argument=42, check_safe_exit=True)
def test_slightly_strange_try_catch(self): # Function either throws the same string back at you, or returns an int +1 func = function_lit( one_of_type([string_type(), int_type()]), try_catch_op( throw_op(dereference("argument")), prepared_function( int_type(), return_op( addition_op(literal_op(1), dereference("argument")))), nop())) _, result = bootstrap_function(func, argument="hello world", check_safe_exit=False) self.assertEquals(result.caught_break_mode, "exception") self.assertEquals(result.value, "hello world") _, result = bootstrap_function(func, argument=41, check_safe_exit=False) self.assertEquals(result.caught_break_mode, "return") self.assertEquals(result.value, 42)