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())
