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_mycb(self): my_cb = Callback('cb', -1, ()) my_cb.open() Output().put('body') self.assertEqual(NI_CALLBACK_TYPE, -1) my_cb.close() my_cb.open() Output().put('body 2') my_cb.close() self.assertEqual(unpack_lines(my_cb.generate_body()), my_cb_body) self.assertEqual(unpack_lines(my_cb.get_all_bodies()), my_cb_body)
def runTest(self): kMainWindow() self.assertEqual(unpack_lines(Output().get()), null_lines) Output().refresh() w = kMainWindow(width=800, height=300, wallpaper='wallpaper', icon='icon') self.assertEqual(unpack_lines(Output().get()), packed_lines) self.assertEqual(w.x, 0) self.assertEqual(w.y, 0) self.assertEqual(w.width, 800) self.assertEqual(w.height, 300) with self.assertRaises(AttributeError): kMainWindow(width=630)
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 test_func(self): x = self.MyFunc('my_func', args=OrderedDict(arg1=int, arg2=BuiltInIntVar)) self.assertEqual(x.id, 0) bi = BuiltInIntVar('BI', def_val=1) val = x(2, bi) self.assertEqual(val._get_compiled(), 'my_func(2, $BI)') self.assertEqual(val._get_runtime(), 3) val = x(val, bi) self.assertEqual(val._get_compiled(), 'my_func(my_func(2, $BI), $BI)') self.assertEqual(val._get_runtime(), 4) y = self.MyFuncInt('y_func', args=OrderedDict(arg1=int, arg2=BuiltInIntVar)) self.assertEqual(y.id, 2) val = y(x(1, bi), bi) self.assertEqual(val._get_compiled(), 'y_func(my_func(1, $BI), $BI)') self.assertEqual(val._get_runtime(), 3) KSP.set_compiled(True) self.assertEqual((y(1, bi) + x(2, bi)).expand(), 'y_func(1, $BI) + my_func(2, $BI)') Output().refresh() y(1, bi) self.assertEqual(Output().get()[-1], 'y_func(1, $BI)') Output().refresh() y(x(1, bi), bi) self.assertEqual(unpack_lines(Output().get()), 'y_func(my_func(1, $BI), $BI)')
def simple_for(self): with For(arr=self.arrX) as seq: for idx, val in enumerate(seq): self.x <<= val if not KSP.is_compiled(): with self.subTest(): self.assertEqual(self.x.val, self.arrX[idx]) if KSP.is_compiled(): out = unpack_lines(self.code) self.assertEqual(out, default_for_string)
def main(self): self.assertEqual(self.x._get_runtime(), 0) with While() as w: while w(lambda x=self.x, y=self.y: x != y): with If(self.y != 10): check() self.y <<= 10 self.x += 1 self.assertEqual(self.x._get_runtime(), self.y._get_runtime()) if KSP.is_compiled(): out = unpack_lines(self.code) self.assertEqual(out, while_string)
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 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): @init def foo(): Output().put('foo_line') @init def bar(): Output().put('bar_line') init(self.cb) self.assertEqual(self.var, 4) self.assertEqual(unpack_lines(InitCallback.generate_body()), init_lines) self.assertEqual(self.var, 5) @release def rls(): Output().put('release') self.assertEqual(unpack_lines(ReleaseCallback.generate_body()), release_lines) rls() self.assertEqual(Output().pop(), 'release')
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 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 runTest(self): script = kScript(r'E:\packages\file.txt', 'myscript', max_line_length=70, compact=True) with self.assertRaises(RuntimeError): script._generate_code() def foo(): kLog(kLog.array, path=r'E:\packages\pyksp\LogFileReader-master/mylog.nka') mw = kMainWindow() buttons_area = kWidget(parent=mw) buttons_area.place_pct(20, 10, 50, 80) ba_bg = kLabel(parent=buttons_area) ba_bg.pack(sticky='nswe') ba_bg.text <<= '' lvl = kLevelMeter(parent=ba_bg, width=20) lvl.pack(sticky='nse') buttons_area.add_grid(3, 2, 20, 20, 20, 20) buttons = [kButton(parent=buttons_area) for b in range(3 * 2)] def b_callback(control): self.switch(kButton.ids, control.id) message(control.id) for idx, b in enumerate(buttons): b.grid(idx % 3, idx // 3) b.bound_callback(b_callback) with For(arr=kButton.ids) as seq: for item in seq: set_control_par_str(item, 'text', 'mybutton') script.main = foo localtime = time.asctime(time.localtime(time.time())) init_line = '{ Compiled on %s }' % localtime self.maxDiff = None self.assertEqual( unpack_lines(script._generate_code()), generated_code.format(init_line=init_line, fname=Function.get_func_name(self.switch)))
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_func_callback(self): ReleaseCallback.open() Output().put('release open') FunctionCallback.open() Output().put('function1 line') self.assertEqual(NI_CALLBACK_TYPE, NI_CB_TYPE_RELEASE) FunctionCallback.open() Output().put('function2 line') self.assertEqual(NI_CALLBACK_TYPE, NI_CB_TYPE_RELEASE) FunctionCallback.close() Output().put('function1 line') FunctionCallback.close() Output().put('release close') ReleaseCallback.close() self.assertEqual(NI_CALLBACK_TYPE, NI_CB_TYPE_INIT) self.assertEqual( Output().get(), ['function1 line', 'function2 line', 'function1 line']) self.assertEqual(unpack_lines(Callback.get_all_bodies()), func_lines)
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())