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)
