itest_with_parameters.py

# This script is licensed under BSD License, see file LICENSE.txt.
#
# (c) TASKING Germany GmbH, 2023
 
import isystem.connect as ic
import isystem.itest as it
 
 
winidea_id = ''
 
 
def init_target() -> ic.ConnectionMgr:
    cmgr = ic.ConnectionMgr()
    cmgr.connect(ic.CConnectionConfig().instanceId(winidea_id))
 
    debug_ctrl = ic.CDebugFacade(cmgr)
    debug_ctrl.reset()
    debug_ctrl.runUntilFunction('main')
    debug_ctrl.waitUntilStopped()
    return cmgr
 
 
def run_test_with_param_in_host_var(test_case: it.PTestCase):
    """
    This function uses host variables to specify test parameters.
    """
    host_vars = ic.CTestHostVars()
    test_spec = 'func: [sum, ["${param1}", 4, 2], retVal]\n' + \
                'expect:\n' + \
                '- retVal == ${param1} + 6'
    test_spec_obj = ic.CTestSpecification.parseTestSpec(test_spec)
 
    for param_a in range(0, 5, 2):
        host_vars.setValue('${param1}', str(param_a))
 
        test_case.itest(test_spec_obj, None, False, host_vars)
 
        print('\nsum test result:', end=' ')
        results = test_case.getTestResultsContainer()
        result = results.nextTestResult()
        if result.isError():
            print(result.toString())
        else:
            print(f"OK a = {param_a}")
 
 
def run_test_with_param_in_string(test_case: it.PTestCase):
    """
    Builds the test specification using Python's string formatting.
    """
 
    for param_a in range(0, 5, 2):
        test_spec = (f'func: [sum, [{param_a}, 2, 1], retVal]\n'
                     f'expect:\n'
                     f'- retVal == 3 + {param_a}')
        test_spec_obj = ic.CTestSpecification.parseTestSpec(test_spec)
 
        test_case.itest(test_spec_obj, None)
 
        print('\nsum test result:', end=' ')
        results = test_case.getTestResultsContainer()
        result = results.nextTestResult()
        if result.isError():
            print(result.toString())
        else:
            print(f"OK a = {param_a}")
 
 
def run_test_with_param_as_local_var(test_case: it.PTestCase):
    """
    Modifies local variable, which is used as function parameter.
    """
    for param_a in range(0, 5, 2):
        test_spec = f"""
          locals:
            a: int
          init:
            a: {param_a}
          func: [sum, [a, 2, 1], retVal]
          expect:
          - retVal == 3 + a"""
 
        test_case.itest(test_spec, None)
 
        print('\nsum test result:', end=' ')
        results = test_case.getTestResultsContainer()
        result = results.nextTestResult()
        if result.isError():
            print(result.toString())
        else:
            print(f"OK a = {param_a}")
 
 
def run_test_with_test_spec_as_object(test_case: it.PTestCase):
    """
    This example uses test specification as a starting point,
    and sets parameters later by using API. 'testSpec' is no longer a string,
    but an object with methods.
    """
 
    test_spec = ic.CTestSpecification()
    func_under_test = test_spec.getFunctionUnderTest(False)
    func_under_test.setName("sum")
    func_under_test.setRetValueName("retVal")
 
    for param_a in range(0, 5, 2):
 
        params = ic.StrVector()
        params.append(str(param_a))
        params.append(str(2))
        params.append(str(3))
        test_spec.getFunctionUnderTest(False).setPositionParameters(params)
 
        exprs = ic.StrVector()
        exprs.append('retVal == 5 + ' + str(param_a))
        test_spec.setExpectedResults(exprs)
 
        print(test_spec.toString())
 
        test_case.itest(test_spec, None)
 
        print('\nsum test result:', end=' ')
        results = test_case.getTestResultsContainer()
        result = results.nextTestResult()
        if result.isError():
            print(result.toString())
        else:
            print(f"OK a = {param_a}")
 
 
def main():
    cmgr = init_target()
    test_case = it.PTestCase(cmgr)
    print("Tests with host variable")
    run_test_with_param_in_host_var(test_case)
    print("Tests with parameter in YAML test specification string.")
    run_test_with_param_in_string(test_case)
    print("Test with parameter as local variable")
    run_test_with_param_as_local_var(test_case)
    print("Use test specification as object.")
    run_test_with_test_spec_as_object(test_case)
 
 
if __name__ == '__main__':
    main()