def test_arrays(self): KSP.set_compiled(True) stack = Stack('test', kArrInt, 10) arr = kArrInt([1, 2, 3, 4, 5]) returned = stack.push(arr)[0] self.assertIsInstance(returned, StackFrameArray) self.assertEqual( returned[1].val, '%_stack_test_arr[1 + (0 + ' + '%_stack_test_idx[$_stack_test_pointer])]') idx = kInt(4) self.assertEqual( returned[idx].val, '%_stack_test_arr[$kInt0 + (0 + ' + '%_stack_test_idx[$_stack_test_pointer])]') with self.assertRaises(IndexError): returned[idx + 1].val stack.pop() returned = stack.push(kLoc(int, 5))[0] self.assertIsInstance(returned, StackFrameArray) self.assertEqual( returned[1].val, '%_stack_test_arr[1 + (0 + ' + '%_stack_test_idx[$_stack_test_pointer])]') idx = kInt(4) self.assertEqual(returned[idx].val, '%_stack_test_arr[$kInt1 + (0 + ' + '%_stack_test_idx[$_stack_test_pointer])]') with self.assertRaises(IndexError): returned[idx + 1].val
def code(self): x = kInt(2, 'x') y = kInt(1, 'y') code = list() Output().set(code) with Select(x): with Case(1): check() y += 1 with Case(2): check() y += 2 with Select(y): with Case(2): check() y += 1 with Case(3): check() CondFalse() with self.assertRaises(KspCondError): with Case(3): pass if not KSP.is_compiled(): self.assertEqual(y.val, 3) else: code = unpack_lines(code) self.assertEqual(code, select_string)
def setUp(self): super().setUp() self.x = kInt(0, 'x') self.y = kInt(10, 'y') self.x <<= 0 self.y <<= 10 self.code = list() Output().set(self.code)
def test_ui_control(self): control_1 = kInt() control_2 = kInt() UiControlCallback.open(control_1) Output().put('control_1_line') UiControlCallback.close() UiControlCallback.open(control_2) Output().put('control_2_line') UiControlCallback.close() with self.assertRaises(RuntimeError): UiControlCallback.open(control_1) self.assertEqual(unpack_lines(UiControlCallback.generate_body()), ui_lines)
def runTest(self): KSP.set_compiled(True) x = kInt(name='x') y = kInt(name='y') self.assertEqual((x + y).expand(), '$x + $y') self.assertEqual((x + y + x).expand(), '$x + $y + $x') self.assertEqual((x + (y + x)).expand(), '$x + ($y + $x)') self.assertEqual((x + y * x).expand(), '$x + $y * $x') self.assertEqual(((x + y) * x).expand(), '($x + $y) * $x') self.assertEqual((x * (y * x)).expand(), '$x * ($y * $x)') self.assertEqual((x * x * y | y * x).expand(), '$x * $x * $y .or. $y * $x') self.assertEqual((x * (x * y | y * x)).expand(), '$x * ($x * $y .or. $y * $x)')
def test_vars(self): x = BuiltInIntVar('x', def_val=7) self.assertEqual(x._get_runtime(), 7) self.assertEqual(x._get_compiled(), '$x') self.assertEqual(x.id, 0) self.assertEqual(x.val, 7) with self.assertRaises(NotImplementedError): x <<= 4 var = kInt(x) self.assertEqual(var.val, 7) y = BuiltInRealVar('y', def_val=3.0, callbacks=(InitCallback, ReleaseCallback)) self.assertEqual(y._get_runtime(), 3.0) self.assertEqual(y._get_compiled(), '~y') self.assertEqual(y.id, 1) y.set_value(2.1) self.assertEqual(y.val, 2.1) arr = BuiltInArrayInt('arr', size=4) with self.assertRaises(NotImplementedError): arr[2] = 3 self.assertEqual(arr.id, 2) arr.set_value(2, 3) self.assertEqual(arr[2], 3) self.assertEqual(arr[2]._get_compiled(), '%arr[2]') self.assertEqual(CURRENT_SCRIPT_SLOT._get_compiled(), '$CURRENT_SCRIPT_SLOT')
def runTest(self): x = kInt(2, 'x') y = kLoc(int) z = kLoc(int, 5) arr = kArrInt([0] * 10, 'arr', size=10) with self.assertRaises(TypeError): StackFrame(1, 1, 1) with self.assertRaises(TypeError): StackFrame(x, (y, 1), z) KSP.set_compiled(True) frame = StackFrame(arr, (x, y), kInt(2, 'idx', is_local=True)) x, y = frame.vars self.assertEqual(x._get_compiled(), '%arr[0 + $idx]') self.assertEqual(x._get_runtime(), 2) self.assertEqual(y._get_compiled(), '%arr[1 + $idx]') self.assertEqual(y._get_runtime(), 0)
def __init__(self, l_type: object, path: str = None) -> None: self._type = l_type self._path = path if l_type is self.pgs: pgs_create_str_key('_log_msg') pgs_create_key('_log_flag', 1) pgs_set_key_val('_log_flag', 0, 2) return if l_type is self.array: if not self._path: self._simple_log_init() else: self._log_with_path_init() self._log_count = kInt(name='_log_count') self._log_prev_count = kInt(name='_log_prev_count') return raise TypeError('wrong log type')
def test_calls(self): KSP.set_compiled(True) self.method() self.assertEqual( unpack_lines(Output().get()), call_out.format(method=Function.get_func_name(self.method))) Output().refresh() x = kInt(name='x') self.method(x) self.assertEqual(x._get_compiled(), '$x') self.assertEqual(x._get_runtime(), 3) self.assertEqual( unpack_lines(Output().get()), call_with_out.format(method=Function.get_func_name(self.method))) Output().refresh() self.inlined = True self.method(x, inline=True) self.assertEqual(unpack_lines(Output().get()), inlined_out) Output().refresh() arr = kArrInt([1, 2, 3, 4, 5]) @func def foo(loc: kArg(int, 5) = arr): with For(arr=loc) as seq: for item in seq: self.method(item) foo() # test for excluding from generation without # "calling" it @func def bar(var: int): self.method() bar(1, inline=True) generated_exec = KspObject.generate_all_executables() self.maxDiff = None self.assertEqual( unpack_lines(generated_exec), executables.format(method=Function.get_func_name(self.method), foo=Function.get_func_name(foo))) Output().refresh() @func def foobar(arg=kLoc(int)): self.method(arg) KSP.in_init(True) foobar() KSP.in_init(False) self.assertEqual(unpack_lines(Output().get()), invoked_in_init)
def test_compiled(self): KSP.set_compiled(True) x = kInt(1, 'x') y = kInt(2, 'y') with If((x < y) | (x == 1)): check() x <<= y with If(y == 2): check() y += 1 with Else((x == 1) & (y == 2)): check() y += 1 with Else(): check() x -= 1 self.assertEqual(unpack_lines(Output().get()), if_lines)
def init_arrays(cls): out = list() if cls.arr is not None: return out cls.idx = kInt(-1, '_for_loop_curr_idx') cls.arr = kArrInt(name='_for_loop_idx', size=cls.__maxlen) out.extend(cls.idx._generate_init()) out.extend(cls.arr._generate_init()) return out
def test_runtime(self): x = kInt(1, 'x') y = kInt(2, 'y') out = list() with If(x < y): check() out.append('True') self.assertEqual(out.pop(), 'True') with If(x == y): check() raise Exception('has to be False') with Else(x > y): check() raise Exception('has to be False') with Else(): out.append('True') self.assertEqual(out.pop(), 'True')
def step(self): x = kInt(name='x') with For(2, 20, 2) as name: for idx, i in enumerate(name): x <<= i if not KSP.is_compiled(): with self.subTest(): self.assertEqual(i, (idx) * 2 + 2) if not KSP.is_compiled(): self.assertEqual(x.val, 18) else: out = unpack_lines(self.code) self.assertEqual(out, step_string)
def __init__(self, name: str, ref_type: (kArrInt, kArrStr, kArrReal), size: int): if ref_type not in (kArrInt, kArrStr, kArrReal): raise TypeError('ref_type can be only ' + f'{(kArrInt, kArrStr, kArrReal)}') prefix = f'_stack_{name}' self._arr = ref_type(name=f'{prefix}_arr', size=size) self._idx = kArrInt(name=f'{prefix}_idx', size=Stack.depth) self._pointer = kInt(-1, f'{prefix}_pointer') self._frames = list() self._init_lines = list() self._init_lines.extend(self._arr._generate_init()) self._init_lines.extend(self._idx._generate_init()) self._init_lines.extend(self._pointer._generate_init())
def test_push(self): self.maxDiff = None KSP.set_compiled(True) stack = Stack('test', kArrInt, 10) x = kInt(1, 'x') y = kInt(2, 'y') arr = kArrInt([3, 4, 5]) ret_x, ret_y, ret_arr = stack.push(x, y, arr) self.assertEqual( ret_x._get_compiled(), '%_stack_test_arr[0 +' + ' %_stack_test_idx[$_stack_test_pointer]]') self.assertEqual( ret_y._get_compiled(), '%_stack_test_arr[1 +' + ' %_stack_test_idx[$_stack_test_pointer]]') self.assertEqual(ret_x._get_runtime(), 1) self.assertEqual(ret_y._get_runtime(), 2) # print(ret_arr._get_runtime()) with For(arr=ret_arr) as s: for idx, var in enumerate(s): self.assertEqual( var._get_compiled(), '%_stack_test_arr[%_for_loop_idx[' + f'$_for_loop_curr_idx] + (2 + ' + '%_stack_test_idx[$_stack_test_pointer])]') self.assertEqual(var._get_runtime(), arr[idx]._get_runtime()) if KSP.is_compiled(): # print(unpack_lines(Output().get())) self.assertEqual(unpack_lines(Output().get()), push_output) Output().refresh() stack.push(kLoc(int), kLoc(int, 3), kLoc(int)) self.assertEqual(unpack_lines(Output().get()), push_lvl2_output)
def __init__(self, name: str, callbacks=all_callbacks, args: OrderedDict = None, def_ret=None, no_parentesis=False): BuiltInFunc.__init__(self, name=name, callbacks=callbacks, args=args, no_parentesis=no_parentesis, def_ret=def_ret) self._var = kInt(name=name, preserve=False, is_local=True, persist=False)
def runTest(self): x = kOut(int) self.assertTrue(x.check(kInt())) with self.assertRaises(TypeError): x.check(2) with self.assertRaises(TypeError): x.check(kArrInt()) y = kOut(str, 2) self.assertTrue(y.check(kArrStr(size=2))) with self.assertRaises(IndexError): y.check(kArrStr(size=4)) with self.assertRaises(TypeError): y.check(2) with self.assertRaises(TypeError): y.check(kStr()) with self.assertRaises(IndexError): y.check(kArrStr(size=1))
def runTest(self): KSP.set_compiled(True) arr = kArrInt([1, 2, 3, 4, 5]) f_arr = StackFrameArray(arr, 2, 5) idx = kInt(2) self.assertEqual(f_arr[idx].val, '%kArrInt0[$kInt0 + 2]') self.assertEqual(f_arr[idx]._get_runtime(), 5) f_arr[idx] <<= 3 self.assertEqual(f_arr[idx].val, '%kArrInt0[$kInt0 + 2]') self.assertEqual(f_arr[idx]._get_runtime(), 3) with For(arr=f_arr) as s: for idx, i in enumerate(s): self.assertEqual( i.val, '%kArrInt0[%_for_loop_idx[$_for_loop_curr_idx] + 2]') for idx, val in enumerate(f_arr.iter_runtime()): self.assertEqual(val, arr[idx + 2]._get_runtime())
def runTest(self): def foo(x: int, y: kArg(int, 3), z=kLoc(int, 2), out=kOut(int), bad: kOut(int) = 1, bad2: int = 'str'): pass sig = signature(foo) x = FuncArg(sig.parameters['x']) self.assertEqual(x.ref_type, (int, KspIntVar)) y = FuncArg(sig.parameters['y']) self.assertEqual(y.ref_type, (int, KspIntVar)) self.assertEqual(y.size, 3) z = FuncArg(sig.parameters['z']) self.assertTrue(z.is_local) self.assertIsInstance(z.default, kLoc) out = FuncArg(sig.parameters['out']) self.assertTrue(out.is_out) self.assertIsInstance(out.default, kOut) with self.assertRaises(TypeError): FuncArg(sig.parameters['bad']) with self.assertRaises(TypeError): FuncArg(sig.parameters['bad2']) with self.assertRaises(TypeError): x.check('') self.assertEqual(x.check(3), 3) with self.assertRaises(TypeError): y.check(1) arr = kArrInt([1, 2]) self.assertEqual(y.check(arr), arr) with self.assertRaises(TypeError): z.check(2) var = kInt(2) self.assertEqual(out.check(var), var)
def folded_for(self): arrY = kArrInt(name='arrY', sequence=[1, 2, 3, 6]) y = kInt(name='y') break_indicies = [0, 2, 3, 3, 3] with For(arr=self.arrX) as seq: for idx, val in enumerate(seq): self.x <<= val with For(arr=arrY) as seq_y: for idx2, val2 in enumerate(seq_y): with If(self.x == val2): check() y <<= val2 with self.subTest(): if not KSP.is_compiled(): self.assertEqual(idx2, break_indicies[idx]) with Else(): check() Break() if KSP.is_compiled(): out = unpack_lines(self.code) self.assertEqual(out, folded_for_string)
def test_exceptions(self): arrX = kArrInt([1, 2, 4], 'arr') with self.assertRaises(KspCondError): For(arr=[1, 2, 5]) with self.assertRaises(KspCondError): For(1, arr=arrX) with self.assertRaises(KspCondError): For(stop=2) with self.assertRaises(KspCondError): For(step=2) with self.assertRaises(KspCondError): For(stop=2, step=2) with self.assertRaises(KspCondError): For(20.3) with self.assertRaises(KspCondError): For(20, 0.3) with self.assertRaises(KspCondError): For(20, 10, 4.0) with self.assertRaises(KspCondError): For() x = kInt(5, 'x') self.assertTrue(For(x)) self.assertTrue(For(arrX[0]))
def runTest(self): str_arr = kArrStr(['one', 'two']) int_arr = kArrInt([1, 2, 3, 4]) def foo(x: int, y: str, z: kArg(float), arr_int: kArg(int, 3), arr_str: kArg(str, 2) = str_arr, loc1=kLoc(float), loc2=kLoc(int, 5), out=kOut(int), out_str=kOut(str, 2)): return True fargs = FuncArgs(foo) out = kInt() pasted1_pos = [1, 'str', 2.1] pasted1_kw = { 'arr_int': int_arr, # 'arr_str': kArrStr(['one', 'two']) 'out': out } f_self, maped1, outs = fargs.map(*pasted1_pos, **pasted1_kw) self.assertTrue(foo(**maped1)) self.assertEqual(maped1['x'], 1) self.assertEqual(maped1['y'], 'str') self.assertEqual(maped1['z'], 2.1) self.assertEqual(maped1['arr_int'], int_arr) self.assertEqual(maped1['arr_str'], str_arr) self.assertEqual(maped1['out'], out) self.assertIsInstance(maped1['out_str'], kLoc) self.assertEqual(outs['out'], out)
def runTest(self): KSP.set_compiled(True) stack = MultiStack('test', 10) _int1 = kInt(1) _int2 = kInt(2) _int_arr = kArrInt([3, 4]) _str1 = kStr('1') _str2 = kStr('2') _str_arr = kArrStr(['3', '4']) _real1 = kReal(1.0) _real2 = kReal(2.0) _real_arr = kArrReal([3.0, 4.0]) self.assertTrue(stack.is_empty()) _int1, _int2, _int_arr, _str1, _str2, _str_arr, _real1, \ _real2, _real_arr = stack.push(_int1, _int2, _int_arr, _str1, _str2, _str_arr, _real1, _real2, _real_arr) self.assertFalse(stack.is_empty()) self.assertEqual(_int1.val, '%_stack_test_int_arr[0 + ' + '%_stack_test_int_idx[$_stack_test_int_pointer]]') self.assertEqual(_int1._get_runtime(), 1) self.assertEqual(_int2.val, '%_stack_test_int_arr[1 + ' + '%_stack_test_int_idx[$_stack_test_int_pointer]]') self.assertEqual(_int2._get_runtime(), 2) self.assertEqual(_int_arr[0].val, '%_stack_test_int_arr[0 + (2 + ' + '%_stack_test_int_idx[$_stack_test_int_pointer])]') self.assertEqual(_int_arr[0]._get_runtime(), 3) self.assertEqual(_int_arr[1].val, '%_stack_test_int_arr[1 + (2 + ' + '%_stack_test_int_idx[$_stack_test_int_pointer])]') self.assertEqual(_int_arr[1]._get_runtime(), 4) self.assertEqual(_str1.val, '!_stack_test_str_arr[0 + ' + '%_stack_test_str_idx[$_stack_test_str_pointer]]') self.assertEqual(_str1._get_runtime(), '1') self.assertEqual(_str2.val, '!_stack_test_str_arr[1 + ' + '%_stack_test_str_idx[$_stack_test_str_pointer]]') self.assertEqual(_str2._get_runtime(), '2') self.assertEqual(_str_arr[0].val, '!_stack_test_str_arr[0 + (2 + ' + '%_stack_test_str_idx[$_stack_test_str_pointer])]') self.assertEqual(_str_arr[0]._get_runtime(), '3') self.assertEqual(_str_arr[1].val, '!_stack_test_str_arr[1 + (2 + ' + '%_stack_test_str_idx[$_stack_test_str_pointer])]') self.assertEqual(_str_arr[1]._get_runtime(), '4') self.assertEqual( _real1.val, '?_stack_test_real_arr[0 + ' + '%_stack_test_real_idx[$_stack_test_real_pointer]]') self.assertEqual(_real1._get_runtime(), 1.0) self.assertEqual( _real2.val, '?_stack_test_real_arr[1 + ' + '%_stack_test_real_idx[$_stack_test_real_pointer]]') self.assertEqual(_real2._get_runtime(), 2.0) self.assertEqual( _real_arr[0].val, '?_stack_test_real_arr[0 + (2 + ' + '%_stack_test_real_idx[$_stack_test_real_pointer])]') self.assertEqual(_real_arr[0]._get_runtime(), 3.0) self.assertEqual( _real_arr[1].val, '?_stack_test_real_arr[1 + (2 + ' + '%_stack_test_real_idx[$_stack_test_real_pointer])]') self.assertEqual(_real_arr[1]._get_runtime(), 4.0) Output().refresh() loc_int, loc_str_arr = stack.push(kLoc(int), kLoc(str, 2)) self.assertEqual(unpack_lines(Output().get()), multi_push) with self.assertRaises(IndexError): stack.push(kLoc(str, 5)) Output().refresh() stack.pop() self.assertEqual(Output().get(), [ 'dec($_stack_test_int_pointer)', 'dec($_stack_test_str_pointer)' ]) Output().refresh() stack.pop() self.assertEqual(Output().get(), [ 'dec($_stack_test_int_pointer)', 'dec($_stack_test_str_pointer)', 'dec($_stack_test_real_pointer)' ]) self.assertTrue(stack.is_empty())
def __init__(self, name: str, callbacks=all_callbacks, args: OrderedDict = None): super().__init__(name, callbacks, args) self._var = kInt(name=name)
def test_message(self): KSP.set_compiled(True) message(3) self.assertEqual(Output().pop(), 'message(3)') message(2, 'string') self.assertEqual(Output().pop(), 'message(2 & ", " & "string")') message(2, 'string', sep=':') with self.assertRaises(AttributeError): message(2, 'string', sep='\n') self.assertEqual(Output().pop(), 'message(2 & ":" & "string")') set_controller(1, 5) self.assertEqual(Output().pop(), 'set_controller(1, 5)') self.assertEqual(CC[1]._get_runtime(), 5) arr = kArrInt(sequence=list(range(11))) self.assertEqual(arr._get_runtime(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) get_event_ids(arr) self.assertEqual(arr._get_runtime(), [0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0]) Output().refresh() seq = [1, 2, 3, 4] arr1, arr2, arr3 = kArrInt(seq), kArrInt(seq), \ kArrInt([2, 3, 4, 5]) self.assertTrue(array_equal(arr1, arr2)) self.assertEqual(Output().pop(), 'array_equal(%kArrInt1, %kArrInt2)') self.assertFalse(array_equal(arr1, arr3)._get_runtime()) self.assertEqual(Output().pop(), 'array_equal(%kArrInt1, %kArrInt3)') self.assertEqual(num_elements(arr1)._get_runtime(), 4) self.assertEqual( num_elements(arr1)._get_compiled(), 'num_elements(%kArrInt1)') self.assertEqual(search(arr3, 4)._get_runtime(), 2) self.assertEqual( search(arr3, 4)._get_compiled(), 'search(%kArrInt3, 4)') x = kInt(4, 'x') self.assertEqual( search(arr3, x)._get_compiled(), 'search(%kArrInt3, $x)') self.assertEqual(search(arr3, x)._get_runtime(), 2) arr2[1]._set_runtime(5) self.assertEqual(arr2._get_runtime(), [1, 5, 3, 4]) sort(arr2, 0) self.assertEqual(arr2._get_runtime(), [1, 3, 4, 5]) sort(arr2, 3) self.assertEqual(arr2._get_runtime(), [5, 4, 3, 1]) KSP.set_compiled(False) self.assertTrue(get_key_color(0) == KEY_COLOR_NONE.id) set_key_color(0, KEY_COLOR_BLUE) self.assertFalse(get_key_color(0) == KEY_COLOR_NONE.id) self.assertTrue(get_key_color(0) == KEY_COLOR_BLUE.id) set_key_type(3, NI_KEY_TYPE_DEFAULT) self.assertEqual(get_key_type(3), NI_KEY_TYPE_DEFAULT.id) KSP.set_compiled(True) self.assertEqual(get_key_name(2)._get_runtime(), '') set_key_name(2, 'named') self.assertEqual(get_key_name(2)._get_runtime(), 'named') with self.assertRaises(RuntimeError): set_key_pressed(1, 1) set_key_pressed_support(1) set_key_pressed(1, 1) self.assertEqual(get_key_triggerstate(1)._get_runtime(), 1) self.assertEqual( get_key_triggerstate(1).val, 'get_key_triggerstate(1)') self.assertEqual( get_engine_par(ENGINE_PAR_RELEASE_TRIGGER, 1, 1, -1)._get_runtime(), 1) self.assertEqual( get_engine_par_disp(ENGINE_PAR_RELEASE_TRIGGER, 1, 1, -1)._get_runtime(), 'display') set_engine_par(ENGINE_PAR_RELEASE_TRIGGER, 50, 1, 1, -1) self.assertEqual( get_engine_par(ENGINE_PAR_RELEASE_TRIGGER, 1, 1, -1)._get_runtime(), 50) self.assertEqual( get_engine_par_disp(ENGINE_PAR_RELEASE_TRIGGER, 1, 1, -1)._get_runtime(), '50') SET_CONDITION(NO_SYS_SCRIPT_RLS_TRIG) self.assertEqual(Output().pop(), 'SET_CONDITION(NO_SYS_SCRIPT_RLS_TRIG)') pgs_create_key('key', 2) self.assertEqual(Output().pop(), 'pgs_create_key(key, 2)') pgs_create_str_key('key') self.assertEqual(Output().pop(), 'pgs_create_str_key(key)') self.assertEqual(pgs_key_exists('key')._get_runtime(), int(1)) self.assertEqual(pgs_str_key_exists('key')._get_runtime(), int(1)) with self.assertRaises(IndexError): pgs_set_key_val('key', 2, 1) pgs_set_key_val('key', 1, 1) self.assertEqual(Output().pop(), 'pgs_set_key_val(key, 1, 1)') self.assertEqual(pgs_get_key_val('key', 1)._get_runtime(), 1) pgs_set_str_key_val('key', 'string') self.assertEqual(Output().pop(), 'pgs_set_str_key_val(key, "string")') self.assertEqual(pgs_get_str_key_val('key')._get_runtime(), 'string')
def setUp(self): super().setUp() self.arrX = kArrInt([1, 3, 4, 6, 8], 'arrX', size=5) self.x = kInt(name='x') self.code = list() Output().set(self.code)