cumulative_module_coverage.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 = ''
 
 
MODULE_NAME = "utils.cpp"
 
 
class Monitor:
    def __init__(self, no_of_sub_tasks):
        self.no_of_sub_tasks = no_of_sub_tasks
        self.test_count = 0
 
    def isCanceled(self):
        pass
 
    def subTask(self, taskDesc):
        print(taskDesc)
 
    def worked(self, count):
        self.test_count += count
        print('#' * self.test_count + '-' * (self.no_of_sub_tasks - self.test_count))
 
 
def init_target() -> ic.ConnectionMgr:
    cmgr = ic.ConnectionMgr()
 
    cmgr.connect(ic.CConnectionConfig().instanceId(winidea_id))
 
    debug_ctrl = ic.CDebugFacade(cmgr)
 
    debug_ctrl.download()
 
    debug_ctrl.runUntilFunction('main')
    debug_ctrl.waitUntilStopped()
 
    return cmgr
 
 
def run_test(connection_mgr: ic.ConnectionMgr) -> ic.CCoverageController2:
    test_case = it.PTestCase(connection_mgr)
 
    test_case.reset()  # just in case there's something left from previous run
 
    print("Target initialized, configuring coverage...")
 
    # Perform coverage initialization with isystem.connect calls.
 
    coverage_ctrl = ic.CCoverageController2(connection_mgr, "moduleCoverage.trd", 'w')
 
    trigger_idx = coverage_ctrl.getActiveTriggerIndex()
 
    coverage_ctrl.setScope(trigger_idx, ic.CCoverageController2.EScopeCustom)
    coverage_ctrl.setProvideAssemblerInfo(trigger_idx, True)
 
    # We want to get coverage of a complete source file
    coverage_ctrl.addArea(trigger_idx, ic.CCoverageController2.EAreaModule, MODULE_NAME)
 
    coverage_ctrl.start()
 
    print("Coverage configured and started!")
 
    # Test specification uses the existing code coverage document.
    testSpec = ic.CTestSpecification.parseTestSpec(
        """
      # abstract base specification defines coverage for all derived tests. 
      run: false  # this is an abstract base test
      analyzer:
        runMode: start              
        document: moduleCoverage.trd # document initialized above
        openMode: a                  # 'append' mode keeps previous coverage data
        coverage:
          isActive: true
      tests: # derived tests execute the function for several parameters to get full coverage
      - func: [fibonacci, [0], rv]
        assert:
          expressions: [rv == 0]
      - func: [get_random]
      - func: [fibonacci, [2], rv]
        assert:
          expressions: [rv = 2]
    """)
 
    monitor = Monitor(testSpec.getNoOfTests(True))
    test_case.runDerivedTests(testSpec, None, monitor)
 
    return coverage_ctrl
 
 
def print_coverage(coverage_ctrl: ic.CCoverageController2):
    # tests have executed, we have to check it the coverage
    coverage_data = ic.CCoverageData2.createInstance(coverage_ctrl,
                                                     'testCvrg.xml',
                                                     True)  # load data to memory
 
    # always check for parser warnings
    warnings = coverage_data.getParserWarnings()
    if warnings:
        print('WARNING(S): ', warnings)
 
    coverage_data.closeParser()  # releases memory and closes XML file
 
    stat = coverage_data.getStatistic(ic.CCoverageStatistic2.EModule, MODULE_NAME)
 
    bytes_all = stat.getBytesAll()
    bytes_executed = stat.getBytesExecuted()
    conditions_all = stat.getConditionsAll()
    conditions_executed = stat.getConditionsExecuted()
    conditions_taken = stat.getConditionsTrue()
    conditions_not_taken = stat.getConditionsFalse()
    conditions_both = stat.getConditionsBoth()
 
    print('code coverage:', 100. * bytes_executed / bytes_all, '%')
    print('conditions executed', 100. * conditions_executed / conditions_all, '%')
    print('conditions taken', 100. * conditions_taken / conditions_all, '%')
    print('conditions not taken', 100. * conditions_not_taken / conditions_all, '%')
    print('conditions both', 100. * conditions_both / conditions_all, '%')
 
 
if __name__ == '__main__':
    cmgr = init_target()
    cvrg_ctrl = run_test(cmgr)
    print_coverage(cvrg_ctrl)