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_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_invalid_list_assignment(self): code = parse(""" function() { List<int> foo = [ { bar: 2 }, { bar: 3 } ]; return foo[0].bar; } """) with self.assertRaises(PreparationException): bootstrap_function(code)
def test_precidence(self): code = parse(""" function() { return (1 + 1) * 23 - 2 * 1 + 2; } """) _, result = bootstrap_function(code) self.assertEquals(result.caught_break_mode, "value") self.assertEquals(result.value, 42)
def test_4(self): code = parse(""" function() { int bestResult = 0, i = 999; while(i >= 100) { int j = 999; while(j >= i) { int testResult = i * j; if(testResult <= bestResult) { break; }; if(testResult > 100000 && testResult > bestResult && testResult / 1 % 10 == testResult / 100000 % 10 && testResult / 10 % 10 == testResult / 10000 % 10 && testResult / 100 % 10 == testResult / 1000 % 10 ) { bestResult = testResult; }; j = j - 1; }; i = i - 1; }; return bestResult; } """, debug=True) _, result = bootstrap_function(code) self.assertEquals(result.value, 906609)
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_returns_string(self): code = parse(""" function() { return "hello"; } """) _, result = bootstrap_function(code) self.assertEquals(result.caught_break_mode, "value") self.assertEquals(result.value, "hello")
def test_initialize_and_return_local(self): code = parse(""" function() { int foo = 40; return foo + 2; } """) _, result = bootstrap_function(code) self.assertEquals(result.caught_break_mode, "value") self.assertEquals(result.value, 42)
def test_14(self): code = parse(""" function() => int { Dictionary<int : int> cachedResults = { 1: 1 }; Function<int => int> testNumber = function(int number) => int { return 0; }; testNumber = function(int number) => int { var cachedResult = cachedResults[number]?; if(cachedResult is int) { return cachedResult; }; int calcedResult = testNumber(number % 2 == 0 ? number / 2 : number * 3 + 1) + 1; cachedResults[number] = calcedResult; return calcedResult; }; Tuple<int...> results = for(var test in <list(range(1, 10))>) { continue testNumber(test); }; return max(|results|); } """, debug=True) _, result = bootstrap_function(code) self.assertEquals(result.value, 20)
def test_12(self): # The original test goes to 500, but I can only do 10 atm... code = parse(""" function() { var countDivisors = function(int number) { int test = number, count = 1; for(var test from range(1, number)) { if(number % test == 0) { count = count + 1; }; }; return count; }; int triangleNumber = 1, step = 2; while(countDivisors(triangleNumber) < 10) { triangleNumber = triangleNumber + step; step = step + 1; }; return triangleNumber; } """, debug=True) _, result = bootstrap_function(code) self.assertEquals(result.value, 120)
def test_7_fast(self): code = parse(""" function() => int { var isPrime = function(int number) => bool { for(var i from range(2, number / 2)) { if(number % i == 0) { return false; }; }; return true; }; int count = 1, test = 3; loop { if(isPrime(test)) { count = count + 1; if(count >= 100) { return test; }; }; test = test + 2; }; } """, debug=True) with environment(**fastest): _, result = bootstrap_function(code) self.assertEquals(result.value, 541)
def test_addition(self): code = parse(""" function() { return 12 + 30; } """) _, result = bootstrap_function(code) self.assertEquals(result.caught_break_mode, "value") self.assertEquals(result.value, 42)
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_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_9(self): code = parse(""" function() { int a = 1, topb = 998; while(a < 998) { int b = topb; while(b > a) { int c = 1000 - a - b; int test = a * a + b * b - c * c; if(test < 0) { topb = b + 1; break; }; if(test == 0) { return a * b * c; }; b = b - 1; }; a = a + 1; }; } """, debug=True) _, result = bootstrap_function(code) self.assertEquals(result.value, 31875000)
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_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_return_argument(self): code = parse(""" function(|int|) { return argument; } """) _, result = bootstrap_function(code, argument=42) self.assertEquals(result.caught_break_mode, "value") self.assertEquals(result.value, 42)
def test_dereference_argument_parameter(self): code = parse(""" function(|Object { foo: int }|) { return foo; } """) _, result = bootstrap_function(code, argument=PythonObject({"foo": 42})) self.assertEquals(result.caught_break_mode, "value") 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_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_multiplication(self): code = parse(""" function() { return 21 * 2; } """) with environment(transpile=True, return_value_optimization=True): _, result = bootstrap_function(code) self.assertEquals(result.value, 42)
def test_1(self): code = parse(""" function(int foo) => int { return foo; } """, debug=True) _, result = bootstrap_function(code, argument=PythonList([5])) self.assertEqual(result.value, 5)
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_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_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)