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 _generate_ex_proxy(self): '''generates lines of function body, wraped in the function <name> end function lines''' if not self.called: return [] out = list() otpt = Output() otpt.blocked = True args = self._cashed_args[0] passed = self._cashed_args[1] FuncStack().push(*args) otpt.blocked = False FunctionCallback.open() otpt.set(out) otpt.put(f'function {self.name()}') self._func(**passed) otpt.put('end function') Output().release() FunctionCallback.close() otpt.blocked = True FuncStack().pop() otpt.blocked = False return out
def test_real(self): KSP.set_compiled(True) x = kArrReal() x.append(2.0) self.assertEqual(Output().pop(), '?kArrReal0[0] := 2.0') self.assertEqual(x[0].val, '?kArrReal0[0]') self.assertEqual(x._get_compiled(), '?kArrReal0') x.append(3.0) self.assertEqual(Output().pop(), '?kArrReal0[1] := 3.0') self.assertEqual(x[1].val, '?kArrReal0[1]') self.assertEqual(x._get_runtime(), [2.0, 3.0]) self.assertEqual(x._generate_init(), ['declare ?kArrReal0[2]']) y = kArrReal([1.0, 2.0, 3.0]) y.append(4.0) self.assertEqual(Output().pop(), '?kArrReal1[3] := 4.0') self.assertEqual(y._get_runtime(), [1.0, 2.0, 3.0, 4.0]) self.assertEqual(y._generate_init(), ['declare ?kArrReal1[4] := (1.0, 2.0, 3.0)']) IName.set_compact(True) z = kArrReal([1.0, 2.0], 'z') self.assertEqual(z.name(), '?z3yxf') self.assertEqual(z[1].val, '?z3yxf[1]') self.assertEqual(z[1]._get_runtime(), 2.0) z.read() self.assertEqual(Output().pop(), 'read_persistent_var(?z3yxf)') self.assertEqual( z._generate_init(), ['declare ?z3yxf[2] := (1.0, 2.0)', 'make_persistent(?z3yxf)']) preserved = kArrReal(name='preserved', preserve=True) self.assertEqual(preserved.name(), '?preserved')
def __init__(self, condition): call = Output().callable_on_put if call: call() Output().callable_on_put = None # if not self.is_compiled(): # if callable(condition): # condition = condition() self.__condition = condition
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 _remove_line(self, line): if not self.is_compiled() or Output().blocked: return line try: line_l = Output().pop() except IndexError: return line if line_l == line: return line Output().put(line_l) return line
def _log_arr_pers(self): Output().put('while(1=1)') with If(self._log_prev_count != self._log_count): check() if not self._path: save_array(self._log_arr, 1) else: save_array_str(self._log_arr, self._path) self._log_prev_count <<= self._log_count wait(200000) Output().put('end while')
def open(self, control: KspVar = None): super().open() if control and control.name() in self.__controls.keys(): raise RuntimeError(f'callback of {control.name()} has' + ' been set yet') if not control: control = self._last_control else: self.__controls[control.name()] = Control(control) Output().release() Output().set(self.__controls[control.name()].lines) self._last_control = control
def test_kReal(self): x = kReal() self.assertEqual(x.val, 0.0) self.assertEqual(x.name(), '~kReal0') self.assertEqual(x._generate_init(), ['declare ~kReal0']) y = kReal(2.0) self.assertEqual(y.val, 2.0) self.assertEqual(y.name(), '~kReal1') self.assertEqual(y._generate_init(), ['declare ~kReal1 := 2.0']) z = kReal(3.0, 'z', persist=True) self.assertEqual(z.val, 3) self.assertEqual(z.name(), '~z') self.assertEqual(z._generate_init(), ['declare ~z := 3.0', 'make_persistent(~z)']) read = kReal() read.read() self.assertEqual(read._generate_init(), ['declare ~kReal2', 'make_persistent(~kReal2)']) self.assertEqual(Output().get()[-1], 'read_persistent_var(~kReal2)') with self.assertWarns(Warning): read.read() read.in_init(False) with self.assertRaises(RuntimeError): read.read() read.in_init(True) IName.set_compact(True) myvar = kReal(1.0, 'myvar') self.assertEqual(myvar.name(), '~cra4x') myvar_preserved = kReal(0.2, 'myvar_preserved', preserve=True) self.assertEqual(myvar_preserved.name(), '~myvar_preserved') IName.set_compact(False) myvar.set_compiled(True) myvar <<= myvar_preserved self.assertEqual(Output().get()[-1], '~cra4x := ~myvar_preserved') self.assertEqual(myvar.val, '~cra4x') self.assertEqual(myvar._get_runtime(), 0.2) myvar <<= myvar_preserved + 1.0 self.assertEqual(Output().get()[-1], '~cra4x := ~myvar_preserved + 1.0') self.assertEqual(myvar._get_runtime(), 1.2) myvar *= 2.0 self.assertEqual(Output().get()[-1], '~cra4x := ~cra4x * 2.0') self.assertEqual(myvar._get_runtime(), 2.4) with self.assertRaises(myvar.TypeWarn): myvar += 1 with self.assertRaises(myvar.TypeWarn): myvar += 'string'
def test_kStr(self): x = kStr() self.assertEqual(x.val, '') self.assertEqual(x.name(), '@kStr0') self.assertEqual(x._generate_init(), ['declare @kStr0']) y = kStr('str') self.assertEqual(y.val, 'str') self.assertEqual(y.name(), '@kStr1') self.assertEqual(y._generate_init(), ['declare @kStr1', '@kStr1 := "str"']) z = kStr('3', 'z', persist=True) self.assertEqual(z.val, '3') self.assertEqual(z.name(), '@z') self.assertEqual(z._generate_init(), ['declare @z', '@z := "3"', 'make_persistent(@z)']) read = kStr() read.read() self.assertEqual(read._generate_init(), ['declare @kStr2', 'make_persistent(@kStr2)']) self.assertEqual(Output().get()[-1], 'read_persistent_var(@kStr2)') with self.assertWarns(Warning): read.read() read.in_init(False) with self.assertRaises(RuntimeError): read.read() read.in_init(True) IName.set_compact(True) myvar = kStr('str', 'myvar') self.assertEqual(myvar.name(), '@cra4x') myvar_preserved = kStr('2', 'myvar_preserved', preserve=True) self.assertEqual(myvar_preserved.name(), '@myvar_preserved') IName.set_compact(False) myvar.set_compiled(True) myvar <<= myvar_preserved self.assertEqual(Output().get()[-1], '@cra4x := @myvar_preserved') self.assertEqual(myvar.val, '@cra4x') self.assertEqual(myvar._get_runtime(), '2') myvar <<= myvar_preserved + 'string' self.assertEqual(Output().get()[-1], '@cra4x := @myvar_preserved & "string"') self.assertEqual(myvar._get_runtime(), '2string') myvar <<= kInt(name='test', value=1, is_local=True) self.assertEqual(Output().pop(), '@cra4x := $test') self.assertEqual(myvar._get_runtime(), '1')
def __exit__(self, exc_type, value, traceback): """Suppresses KspCondFalse and builds 'end if' lines on KspCondBrake exceptions.""" if exc_type is not None: if not isinstance(value, (KspCondFalse, KspCondBrake)): return if self.is_compiled(): if exc_type is KspCondBrake: raise KspCondBrake('end if') Output().put('end if') Output().callable_on_put = If.refresh if exc_type is KspCondBrake: return return True
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 __exit__(self, exc, value, trace): if self._blocked: self._blocked = False Output().blocked = False if exc is not None: if exc is not KspCondBrake: return if self.is_compiled(): # if isinstance(value, KspCondBrake): # if str(value) != '': # raise KspCondError( # 'While loop can not be breaked') Output().put('end while') return True
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 __exit__(self, exc, value, trace): '''Supresses Brake exceptions and generates postfix (end) code''' if exc is not None and exc is not KspCondBrake: if self._out_touched: Output().blocked = False self._out_touched = False return if isinstance(value, KspCondBrake): self.__idx <<= len(self.__seq) Output().put(f'{value}') self.__generate_exit_code() if self._out_touched: Output().blocked = False self._out_touched = False return True
def is_after_if(self): """Checks amount of statements and raises exception if can_be_else is empty (pure KSP code before Else())""" try: if_result = can_be_else.pop() except IndexError: raise KspCondError('has to be right after If()') for item in if_result: self.__if_count += 1 if self.is_compiled() and Output().blocked is not True: if Output().pop() != 'end if': raise\ KspCondError( 'something is wrong here. Library bug.') last_result = item return last_result
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 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 __range_handler(self): '''Under tests returns generator over range(args) function Under compilation idx assignement and while cond lines''' self.__idx <<= self.__start if self.is_compiled(): Output().put( f'while({self.__idx.val} < {get_string_repr(self.__stop)})') for i in range(*get_runtime(*self.__args)): self.__idx._set_runtime(i) if i > get_runtime(self.__start) and \ self.is_compiled()and not Output().blocked: self._out_touched = True Output().blocked = True yield self.__idx if self._out_touched: self._out_touched = False Output().blocked = False return
def __exit__(self, exc_type, value, trace): """Supresses KspCondFalse and add KspCondError to Output() for preventing KSP code before end select or new Case""" if exc_type is not None: if not isinstance(value, KspCondFalse): return Output().exception_on_put = KspCondError( '''Wrong syntax. all code hase to be in Case block''') return True
def _set_compiled(self, other): if isinstance(other, KspNumeric): runtime = f'{other._get_runtime()}' else: runtime = other if isinstance(other, str): other = f'"{other}"' self._set_runtime(runtime) Output().put(AstAssign(self, other).expand())
def __generate_exit_code(self): '''inc(self.__idx) if for, step line if range''' if self.is_compiled(): if self.__func == self.__foreach_handler: self.__idx.inc() if self.__func == self.__range_handler: self.__idx += self.__step Output().put('end while') For.idx.dec()
def __is_else(self): """Checks the condition and puts 'else' to Output()""" # self.__if_result = self.is_after_if() if not self.is_compiled(): if self.__if_result: # If.__condition = False check(False) return return True Output().put('else')
def __is_elif(self): """Restoring if order inside can_be_else, puts to Output() else and if(condition) lines""" cond = self.__condition if not self.is_compiled() and not cond: # If.__condition = False check(False) return result = list() for idx in range(self.__if_count): result.append(False) result.append(cond) self.__if_count += 1 can_be_else.append(result) if self.is_compiled(): Output().put('else') self.set_bool(True) Output().put(f'if({cond.expand()})') self.set_bool(False)
def test_pop(self): KSP.set_compiled(True) stack = Stack('test', kArrInt, 10) with self.assertRaises(IndexError): stack.pop() stack.push(kLoc(int), kLoc(int, 2), kLoc(int)) stack.pop() self.assertEqual(Output().pop(), 'dec($_stack_test_pointer)')
def put(self, *args, sep=' '): self._check_sep(sep) line = '' for idx, arg in enumerate(args): if idx != 0: line += f' & "{sep}" & ' if isinstance(arg, str): arg = f'"{arg}"' if hasattr(arg, '_get_compiled'): arg = arg._get_compiled() if hasattr(arg, 'expand'): arg = arg.expand() line += f'{arg}' if self._type == self.pgs: Output().put(f'pgs_set_str_key_val(_log_msg, {line})') pgs_set_key_val('_log_flag', 0, 1) if self._type is self.array: var = self._log_arr[self._log_count]._get_compiled() Output().put(f'{var} := {line}') self._log_count <<= (self._log_count + 1) % 32768
def tearDown(self): KspObject.refresh() Output().refresh() Callback.refresh() # Function.refresh() BuiltIn.refresh() refresh_names_count() IName.refresh() gui_refresh() For.refresh() KSP.refresh()
def __foreach_handler(self): '''Uder tests returns iterator over self.__seq, under compilation idx assignement and while cond lines''' self.__idx <<= 0 if self.is_compiled(): Output().put(f'while({self.__idx.val} < {len(self.__seq)})') for idx in range(len(self.__seq)): if idx > 0 and self.is_compiled() and not Output().blocked: self._out_touched = True Output().blocked = True self.__idx._set_runtime(idx) item = self.__seq[self.__idx] yield item if self._out_touched: Output().blocked = False self._out_touched = False return # yield out return True
def __call__(self, condition: bool): if self.__count and not Output().blocked: self._blocked = True Output().blocked = True if callable(condition): condition = condition() self.__condition = condition if not self.is_compiled(): if self.__condition: return True raise KspCondBrake() if self.__condition.get_value(): self.set_bool(True) Output().put(f'while({self.__condition.expand()})') self.set_bool(False) self.__count += 1 return True if self._blocked: self._blocked = False Output().blocked = False raise KspCondBrake()