Python-сообщество

 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():
                        self.assertEqual(
                            idx2, break_indicies[idx])
                with Else():
                    check()
                    Break()

inc($_for_loop_curr_idx)
%_for_loop_idx[$_for_loop_curr_idx] := 0
while(%_for_loop_idx[$_for_loop_curr_idx] < 5)
    $x := %arrX[%_for_loop_idx[$_for_loop_curr_idx]]
    inc($_for_loop_curr_idx)
    %_for_loop_idx[$_for_loop_curr_idx] := 0
    while(%_for_loop_idx[$_for_loop_curr_idx] < 4)
        if($x = %arrY[%_for_loop_idx[$_for_loop_curr_idx]])
            $y := %arrY[%_for_loop_idx[$_for_loop_curr_idx]]
        else
            %_for_loop_idx[$_for_loop_curr_idx] := 4
        end if
        inc(%_for_loop_idx[$_for_loop_curr_idx])
    end while
    dec($_for_loop_curr_idx)
    inc(%_for_loop_idx[$_for_loop_curr_idx])
end while
dec($_for_loop_curr_idx)

 @func
def method(self, arg=kOut(int)):
    self.assertEqual(
        arg.name(),
        '%_stack_functions_int_arr[0 + %_stack_functions_int_idx' +
        '[$_stack_functions_int_pointer]]')
    arg <<= self.int
def test_funcs(self):
    @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)))

 init_lines = \
    '''on init
foo_line
bar_line
cb body is 4
end on'''
release_lines = \
    '''on release
release
end on'''
class TestWrapers(DevTest):
    def setUp(self):
        Output().refresh()
        self.var = 4
    def cb(self):
        Output().put(f'cb body is {self.var}')
        self.var += 1
    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')

  path = os.path.abspath(os.path.dirname(__file__)) + '/..'
sys.path.append(path)
path = os.path.abspath(os.path.dirname(__file__))
sys.path.append(path)
from mytests import DevTest

 from pyksp.compiler.tests.mytests import DevTest

 class Test:
    count = 0

 from simple_test import Test
class Script1:
    Test.count += 1
    print(Test.count)

 from simple_test import Test
class Script2:
    Test.count += 1
    print(Test.count)

 from simple_test2 import Script1
from simple_test3 import Script2
from simple_test import Test
import importlib
import importlib.util
Test.count = 0
class Runner:
    def __init__(self, cls):
        spec = importlib.util.find_spec(cls.__module__)
        mod = importlib.util.module_from_spec(spec)
        spec.loader.exec_module(mod)
a = Runner(Script1)
b = Runner(Script2)

 1
2
1
2
[Finished in 0.1s]