This section describes how to specify test step in YAML format (version 1.1). YAML is language used for structured data representation, which is human readable and machine parseable. It is easier to read than XML, and much easier to write. More information is available at Wikipedia and The Official YAML Web Site.

Conventions

Bold and underlined - used for mandatory tags and default values
Code - used for examples and code
Italics - used for emphasis
Frames with different background colors are used to show the following:

Test Specification Syntax

Example, which demonstrates usage, but can not be run standalone.

Example, which represents complete test and can be run with SDK winIDEA project.

Operators '*', '&', and [] in C/C++ and YAML

YAML uses characters '&' and '*' to define anchors and references. This conflicts with operators in C, so we must quote all strings, which start with '&' or '*', when specifying C operators.

Examples:

  - ax == &g    # OK, because YAML list item is scalar 'ax == &g',
                # which does not start with '&'

   ptr1: '&g'    # must be quoted, because mapping pair is composed of
                # scalars 'ptr1' and '&g'. Scalar '&g' starts with '&',
                # so quoting is needed.

   '*ptr1': 10   # must be quoted, because mapping key '*ptr1' starts with '*'

Another issue are square brackets '[' and ']', which are used for lists in YAML flow style, and for array indices in C/C++. They have to be quoted always when they are the first char in string, or when they are used in YAML flow style lists, even if they do not start the string. To be on the safe side, use single quotes for all strings which contain square brackets.

Quotes in test specifications

Since both C and YAML use single and double quotes, it is important to understand quoting in YAML and C and how it is used in isystem.test.

YAML understands three types of strings. The string type is determined by the first character. If it is single quote ('), it is single quoted string, if it is double quote ("), it is double quoted string, and it is plain string in all other cases. If the first character is not quote (single or double), it is a plain string, even if quotes appear inside of the string. Detailed descriptions follow:

plain strings are strings, which are not surrounded with quotes and do not support escaping. Characters with special meaning in YAML are not allowed in plain strings. These are: & * , : # { } [ ]
In isystem.test plain strings are used for single word items, like tags, function names, parameter names, and variable names. Examples:
```
    locals:
      myVar: int
    desc: This is test description.
  
```
If quotes appear inside plain string, they are treated as any other character, for example:
```
    expect:
    - retVal == 'a'
  
```
The plain string here is retVal == 'a'. Quotes have no special meaning for YAML parser.
single quoted strings in YAML support no escaping, except single quote itself, which is written as two single quotes. In isystem.test single quotes are used for specifying character constants, and when '&', '*' or '[]' are used as C operators. Example:
```
  locals:
    myvar: char
    singleQuote: char
  init:
    myVar: 's'
    singleQuote: '\'''  # backslash is required for C evaluator, which gets: '\''
  function: [myFunction, ['&myvar', 'a[0]'], retVal]
  expect:
  - retVal == '\''
  
```
Note the last line in example, where the single quote is not escaped, because this line contains a plain string retVal == '\'', not quoted string.
double quoted strings in YAML support escaping with . In isystem.test these strings are used for specifying string literals, which can be used for initialization of character arrays, for example:
```
  locals:
    array: char [15]
  init:
    array: "Hello!"
  func: [f, [array]]
  
```
Backslash '\' character in strings must be escaped as in C, for example:
```
  "\\home\\test\n"  # string ends with newline character
  
```

Example of complete test specification:

  locals:
    a: char[10]
    b: char[15]
    c: char[5]
    d: char[20]
    pd: 'char *'
  init:
    a: "elephant"
    b: "horse"
    c: ""   
    pd: '&d'
    d: "monitor"
  func: [funcTestCharArray2, [a, b, c], charRetVal]
  expect:
  - a[0] == 'f'
  - a == "flephant"
  - b[1] == 'g'
  - c[0] == 0
  - c[2] == 'h'
  - pd == "monitor"
  - pd == &d
  - charRetVal[2] == 'h'

More details about quotes in YAML can be found at The Official YAML Web Site.

Host variables

Test specifications may use also variables, which are defined on host only. These variables should be prefixed with $ and surrounded with {}:

      ${<varName>}

for example:

      ${expectedValue}

These variables do not have to be declared, and they always contain strings. Inside test specification they are simply replaced with their value. To use them, we simply assign value to them in Variables section, and then use them in expressions.

Reserved host variables

Host variables must start with a letter. They may contain also numbers and underscores in their name, but not as the first character. Names starting with underscore are reserved, and will be defined by iSYSTEM.

Predefined host variables

Predefined host variables are created automatically by isystem.test and can be used in expressions. The following host variables are predefined:

${_rv} - function return value
${_p<n>} - value of function parameter, where n is parameter index, for example {_p1} refers to first function parameter.
-

Global host variables

User defined host variable with prefix g_ are global variables, which means they will be available in all succeeding test cases. Their value can be changed, but once defined they can not be deleted.

Test specification syntax

This section contains test specification syntax, which includes test environment and test cases.

env: 
  version: <xx.yy.zz>
  workspace: <pathToWinIDEAWorkspaceFile>
  useQualifiedFuncName: <true | false>
  address: <ipAddrOrHostName>
  port: <portNumber>
  coreIds: [<coreId-0>, ...]
  autoConnect: <true | false>
  autoIdFormat: <formatString>
  defaultRetValName: <varName>
  logFile: [<fileName>, ...]
  initBeforeRun: <true | false>
  disableInterrupts: <true | false>
  testTimeout: <timeout>
  breakpointType: <keepWinIDEASetting | useHWBreakpoints | useSWBreakpoints | useHWBPsForInitThenSWBPs>
  initSequence: 
  - coreId: <coreId>
    action: <connectToCore | download | reset | run | delAllBreakpoints | callTargetFunction | callScriptFunction | loadSymbolsOnly | waitUntilStopped>
    params: [<param0>, ...]
  - ...
  scriptConfig: 
    workingDir: <directory>
    modules: [<moduleName>, ...]
    sysPaths: [<sysPath>, ...]
    timeout: <timeInSeconds>
    extensionClass: <scriptClassName>
  toolsConfig: 
    isAutoSetAnalyzerFName: <true | false>
    analyzerFName: <fileName>
    isSetTestIdOnPaste: <true | false>
  evaluatorConfig: 
    isOverrideWinIDEASettings: <true | false>
    charDisplay: <ASCII | Integer | Both>
    isAnsiChar: <true | false>
    isHex: <true | false>
    binaryDisplay: <Blanks | NoBlanksTrailingB>
    isDisplayPointerMemArea: <true | false>
    isCharArrayAsString: <true | false>
    isDereferenceStringPointers: <true | false>
    addressDisplay: <HexNoPrefix | HexPrefix>
    enumDisplay: <Enum | Integer | Both>
    isDisplayCollapsedArrayStruct: <true | false>
    vagueFloatPrecision: <floatNumber>
  testCaseTargetInit: 
    downloadOnTCInit: <true | false>
    resetOnTCInit: <true | false>
    runOnTCInit: <true | false>
    stopFunctionOnTCInit: <functionName>
  stackUsageOptions: 
  - coreId: <coreId>
    isActive: <true | false>
    baseAddr: <address>
    endAddr: <address>
    pattern: <bytePattern>
  - ...
  checkTargetState: <true | false>
  verifySymbolsBeforeRun: <true | false>
reportConfig: 
  testIDEAVersion: <version>
  winIDEAVersion: <version>
  reportContents: <full | errorsOnly>
  outFormat: <xml | yaml | csv | xls | xlsx>
  fileName: <fileName>
  iyamlFileName: <iyamlFileName>
  xsltFull: <fileName>
  xsltErrors: <fileName>
  xmlLogoImage: <>
  xmlReportHeader: <>
  cssFile: <>
  isEmbeddedXsltCss: <true | false>
  isCreateHtml: <true | false>
  csvSeparator: <char>
  isCSVHeaderLine: <true | false>
  isXLSVerticalHeader: <true | false>
  isIncludeTestSpec: <true | false>
  isAbsPathForLinks: <true | false>
  htmlViewMode: <all | errorsOnly>
  testInfo: {<key>: <value>, ...}
  useCustomTime: <true | false>
testFilters: 
- filterId: <>
  type: <builtIn | script>
  coreId: <>
  partitions: [<partition>, ...]
  modules: [<>, ...]
  includedIds: [<testId>, ...]
  excludedIds: [<testId>, ...]
  includedFunctions: [<functionName>, ...]
  excludedFunctions: [<functionName>, ...]
  mustHaveAllTags: [<tag>, ...]
  mustHaveOneOfTags: [<tag>, ...]
  mustNotHaveAllTags: [<tag>, ...]
  mustNotHaveOneOfTags: [<tag>, ...]
  isOr1: <true | false>
  isOr2: <true | false>
  isOr3: <true | false>
  scriptFunction: <scriptFunctionName>
  scriptFunctionParams: [<scriptFunctionParam>, ...]
- ...
groups: 
  id: <>
  isExecute: <true | false>
  desc: <text>
  filter: 
    filterId: <>
    type: <builtIn | script>
    coreId: <>
    partitions: [<partition>, ...]
    modules: [<>, ...]
    includedIds: [<testId>, ...]
    excludedIds: [<testId>, ...]
    includedFunctions: [<functionName>, ...]
    excludedFunctions: [<functionName>, ...]
    mustHaveAllTags: [<tag>, ...]
    mustHaveOneOfTags: [<tag>, ...]
    mustNotHaveAllTags: [<tag>, ...]
    mustNotHaveOneOfTags: [<tag>, ...]
    isOr1: <true | false>
    isOr2: <true | false>
    isOr3: <true | false>
    scriptFunction: <scriptFunctionName>
    scriptFunctionParams: [<scriptFunctionParam>, ...]
  mergedAnalyzerFile: <fileName.trd>
  isCloseAfterTest: <true | false>
  coverageExport: 
    isActive: <true | false>
    isMeasureAllFunctions: <true | false>
    isIgnoreNonReachableCode: <true | false>
    mergeScope: <none | siblingsOnly | siblingsAndParent | all>
    mergeFilter: 
      filterId: <>
      type: <builtIn | script>
      coreId: <>
      partitions: [<partition>, ...]
      modules: [<>, ...]
      includedIds: [<testId>, ...]
      excludedIds: [<testId>, ...]
      includedFunctions: [<functionName>, ...]
      excludedFunctions: [<functionName>, ...]
      mustHaveAllTags: [<tag>, ...]
      mustHaveOneOfTags: [<tag>, ...]
      mustNotHaveAllTags: [<tag>, ...]
      mustNotHaveOneOfTags: [<tag>, ...]
      isOr1: <true | false>
      isOr2: <true | false>
      isOr3: <true | false>
      scriptFunction: <scriptFunctionName>
      scriptFunctionParams: [<scriptFunctionParam>, ...]
    exportFormat: <HTML | Text | CSV | XML | Review (HTML) | Review (Text)>
    formatVariant: <variantName>
    exportFile: <fileName>
    isAssemblerInfo: <true | false>
    isLaunchViewer: <true | false>
    isExportModuleLines: <true | false>
    isExportSources: <true | false>
    isExportFunctionLines: <true | false>
    isExportAsm: <true | false>
    isExportRanges: <true | false>
    exportFunctionsFilter: <functionName>
    exportModulesFilter: <moduleName>
    statistics: 
    - func: <functionName>
      code: <percentage>
      sourceLines: <percentage>
      branches: <percentage>
      taken: <percentage>
      notTaken: <percentage>
      both: <percentage>
      execCount: <>
    - ...
  coverageAllCodeInGroup: 
    func: <functionName>
    code: <percentage>
    sourceLines: <percentage>
    branches: <percentage>
    taken: <percentage>
    notTaken: <percentage>
    both: <percentage>
    execCount: <>
  coverageTestCasesOnly: 
    func: <functionName>
    code: <percentage>
    sourceLines: <percentage>
    branches: <percentage>
    taken: <percentage>
    notTaken: <percentage>
    both: <percentage>
    execCount: <>
  initScriptFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  endScriptFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  children: 
  - 
  - ...
testCases: 
  id: <>
  testScope: <unitTest | systemTest>
  baseId: <>
  run: <true | false>
  imports: 
    id: 
      inherit: <true | false>
      ids: [<testId>, ...]
    scope: 
      inherit: <true | false>
      ids: [<testId>, ...]
    desc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    tags: 
      inherit: <true | false>
      ids: [<testId>, ...]
    options: 
      inherit: <true | false>
      ids: [<testId>, ...]
    persistVars: 
      inherit: <true | false>
      ids: [<testId>, ...]
    locals: 
      inherit: <true | false>
      ids: [<testId>, ...]
    init: 
      inherit: <true | false>
      ids: [<testId>, ...]
    beginStopCondition: 
      inherit: <true | false>
      ids: [<testId>, ...]
    endStopCondition: 
      inherit: <true | false>
      ids: [<testId>, ...]
    func: 
      inherit: <true | false>
      ids: [<testId>, ...]
    testTimeout: 
      inherit: <true | false>
      ids: [<testId>, ...]
    coreId: 
      inherit: <true | false>
      ids: [<testId>, ...]
    initTargetFunc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    initFunc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    endFunc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    restoreTargetFunc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    stubs: 
      inherit: <true | false>
      ids: [<testId>, ...]
    userStubs: 
      inherit: <true | false>
      ids: [<testId>, ...]
    testPoints: 
      inherit: <true | false>
      ids: [<testId>, ...]
    preCondition: 
      inherit: <true | false>
      ids: [<testId>, ...]
    assert: 
      inherit: <true | false>
      ids: [<testId>, ...]
    stackUsage: 
      inherit: <true | false>
      ids: [<testId>, ...]
    log: 
      inherit: <true | false>
      ids: [<testId>, ...]
    analyzer: 
      inherit: <true | false>
      ids: [<testId>, ...]
    hil: 
      inherit: <true | false>
      ids: [<testId>, ...]
    dryRun: 
      inherit: <true | false>
      ids: [<testId>, ...]
    diagrams: 
      inherit: <true | false>
      ids: [<testId>, ...]
    params: 
      inherit: <true | false>
      ids: [<testId>, ...]
  desc: <text>
  tags: [<tag>, ...]
  options: {<winIDEAOptionPath>: <optionValue>, ...}
  persistVars: 
    decl: {<varName>: <varType>, ...}
    delete: [<varName>, ...]
    isDeleteAll: <true | false>
  locals: {<varName>: <varType>, ...}
  init: {<varName>: <varValue>, ...}
  beginStopCondition: 
    stopType: <breakpoint | stop | rtExpression | noRun>
    timeout: <milliseconds>
    rtExpression: <expression>
    conditionCount: <count>
    conditionExpr: <expression>
    bpLocation: 
      resourceType: <function | file | address>
      resourceName: <fileName or functionName>
      srcFileLocation: <localHost | winIDEAHost>
      line: <number>
      isSearch: <true | false>
      linesRange: <number>
      searchContext: <any | code | comment>
      matchType: <plain | regEx | testPointId>
      pattern: <pattern>
      lineOffset: <number>
      numSteps: <number>
  endStopCondition: 
    stopType: <breakpoint | stop | rtExpression | noRun>
    timeout: <milliseconds>
    rtExpression: <expression>
    conditionCount: <count>
    conditionExpr: <expression>
    bpLocation: 
      resourceType: <function | file | address>
      resourceName: <fileName or functionName>
      srcFileLocation: <localHost | winIDEAHost>
      line: <number>
      isSearch: <true | false>
      linesRange: <number>
      searchContext: <any | code | comment>
      matchType: <plain | regEx | testPointId>
      pattern: <pattern>
      lineOffset: <number>
      numSteps: <number>
  func: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  testTimeout: <timeout>
  coreId: <coreId>
  initTargetFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  initFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  endFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  restoreTargetFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  stubs: 
  - stubbedFunc: <functionName>
    isActive: <true | false>
    isCustomActivation: <true | false>
    params: [<parameter>, ...]
    retValName: <varName>
    scriptFunc: <functionName>
    hitLimits: 
      min: <numHits>
      max: <numHits>
    log: 
      before: [<varName>, ...]
      after: [<varName>, ...]
    assignSteps: 
    - expect: [<expression>, ...]
      assign: {<varName>: <varValue>, ...}
      scriptParams: [<parameter>, ...]
      next: <index>
    - ...
  - ...
  userStubs: 
  - func: <functionName>
    isActive: <true | false>
    replacementFunc: <functionName>
  - ...
  testPoints: 
  - tpId: <>
    isActive: <true | false>
    isCustomActivation: <true | false>
    conditionCount: <count>
    conditionExpr: <expression>
    scriptFunc: <functonName>
    location: 
      resourceType: <function | file | address>
      resourceName: <fileName or functionName>
      srcFileLocation: <localHost | winIDEAHost>
      line: <number>
      isSearch: <true | false>
      linesRange: <number>
      searchContext: <any | code | comment>
      matchType: <plain | regEx | testPointId>
      pattern: <pattern>
      lineOffset: <number>
      numSteps: <number>
    log: 
      before: [<varName>, ...]
      after: [<varName>, ...]
    hitLimits: 
      min: <numHits>
      max: <numHits>
    steps: 
    - expect: [<expression>, ...]
      assign: {<varName>: <varValue>, ...}
      scriptParams: [<parameter>, ...]
      next: <index>
    - ...
  - ...
  preCondition: 
    isExpectException: <true | false>
    expressions: [<C expression>, ...]
  assert: 
    isExpectException: <true | false>
    expressions: [<C expression>, ...]
  stackUsage: 
    minLimit: <numBytes>
    maxLimit: <numBytes>
  log: 
    before: [<varName>, ...]
    after: [<varName>, ...]
  analyzer: 
    runMode: <off | start>
    document: <fileName>
    openMode: <u | w | a>
    isSlowRun: <true | false>
    trigger: <triggerName>
    isPredefTrigger: <true | false>
    isSaveAfterTest: <true | false>
    isCloseAfterTest: <true | false>
    trace: 
      isActive: <true | false>
      exportFormat: <Text | CSV | Binary | XML>
      exportFile: <fileName>
    coverage: 
      isActive: <true | false>
      isMeasureAllFunctions: <true | false>
      isIgnoreNonReachableCode: <true | false>
      mergeScope: <none | siblingsOnly | siblingsAndParent | all>
      mergeFilter: 
        filterId: <>
        type: <builtIn | script>
        coreId: <>
        partitions: [<partition>, ...]
        modules: [<>, ...]
        includedIds: [<testId>, ...]
        excludedIds: [<testId>, ...]
        includedFunctions: [<functionName>, ...]
        excludedFunctions: [<functionName>, ...]
        mustHaveAllTags: [<tag>, ...]
        mustHaveOneOfTags: [<tag>, ...]
        mustNotHaveAllTags: [<tag>, ...]
        mustNotHaveOneOfTags: [<tag>, ...]
        isOr1: <true | false>
        isOr2: <true | false>
        isOr3: <true | false>
        scriptFunction: <scriptFunctionName>
        scriptFunctionParams: [<scriptFunctionParam>, ...]
      exportFormat: <HTML | Text | CSV | XML | Review (HTML) | Review (Text)>
      formatVariant: <variantName>
      exportFile: <fileName>
      isAssemblerInfo: <true | false>
      isLaunchViewer: <true | false>
      isExportModuleLines: <true | false>
      isExportSources: <true | false>
      isExportFunctionLines: <true | false>
      isExportAsm: <true | false>
      isExportRanges: <true | false>
      exportFunctionsFilter: <functionName>
      exportModulesFilter: <moduleName>
      statistics: 
      - func: <functionName>
        code: <percentage>
        sourceLines: <percentage>
        branches: <percentage>
        taken: <percentage>
        notTaken: <percentage>
        both: <percentage>
        execCount: <>
      - ...
    profiler: 
      isActive: <true | false>
      isMeasureAllFunctions: <true | false>
      exportFormat: <Text | XML | CSV | Text1 | XMLBinaryTimeline | BTF | MDF>
      exportFile: <>
      isExportActiveOnly: <true | false>
      isProfileAUX: <true | false>
      isSaveHistory: <true | false>
      codeAreas: 
      - name: <funcName or varName>
        value: <stateValue>
        netTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        grossTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        callTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        periodTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        outsideTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        hits: [<number>, ...]
      - ...
      dataAreas: 
      - name: <funcName or varName>
        value: <stateValue>
        netTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        grossTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        callTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        periodTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        outsideTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        hits: [<number>, ...]
      - ...
  hil: 
    params: {<hilParamName>: <hilParamValue>, ...}
  dryRun: 
    assign: {<hostVarName>: <expression>, ...}
    isUpdateCoverage: <true | false>
    isUpdateProfiler: <true | false>
    profilerMultiplier: <>
    profilerOffset: <>
  diagrams: 
    isActive: <true | false>
    diagrams: 
    - isActive: <true | false>
      diagramType: <flowChart | sequenceDiagram | callGraph | staticCallGraph | flameGraph | custom | customAsync>
      script: <scriptName.py>
      params: [<arg1>, ...]
      outFile: <fileName>
      isAddToReport: <true | false>
      viewer: <multiPage | singlePage | externalApp | none>
      dataFormat: <byExtension | bitmap | SVG>
      externalViewer: <pathToApp>
    - ...
  tests: 
  - 
  - ...

env (isys::CTestEnvironmentConfig)

This section defines environment for test execution. It contains configuration items for winIDEA and testIDEA.

Syntax:

env:
  version: <xx.yy.zz>
  workspace: <pathToWinIDEAWorkspaceFile>
  useQualifiedFuncName: <true | false>
  address: <ipAddrOrHostName>
  port: <portNumber>
  coreIds: [<coreId-0>, ...]
  autoConnect: <true | false>
  autoIdFormat: <formatString>
  defaultRetValName: <varName>
  logFile: [<fileName>, ...]
  initBeforeRun: <true | false>
  disableInterrupts: <true | false>
  testTimeout: <timeout>
  breakpointType: <keepWinIDEASetting | useHWBreakpoints | useSWBreakpoints | useHWBPsForInitThenSWBPs>
  initSequence: 
  - coreId: <coreId>
    action: <connectToCore | download | reset | run | delAllBreakpoints | callTargetFunction | callScriptFunction | loadSymbolsOnly | waitUntilStopped>
    params: [<param0>, ...]
  - ...
  scriptConfig: 
    workingDir: <directory>
    modules: [<moduleName>, ...]
    sysPaths: [<sysPath>, ...]
    timeout: <timeInSeconds>
    extensionClass: <scriptClassName>
  toolsConfig: 
    isAutoSetAnalyzerFName: <true | false>
    analyzerFName: <fileName>
    isSetTestIdOnPaste: <true | false>
  evaluatorConfig: 
    isOverrideWinIDEASettings: <true | false>
    charDisplay: <ASCII | Integer | Both>
    isAnsiChar: <true | false>
    isHex: <true | false>
    binaryDisplay: <Blanks | NoBlanksTrailingB>
    isDisplayPointerMemArea: <true | false>
    isCharArrayAsString: <true | false>
    isDereferenceStringPointers: <true | false>
    addressDisplay: <HexNoPrefix | HexPrefix>
    enumDisplay: <Enum | Integer | Both>
    isDisplayCollapsedArrayStruct: <true | false>
    vagueFloatPrecision: <floatNumber>
  testCaseTargetInit: 
    downloadOnTCInit: <true | false>
    resetOnTCInit: <true | false>
    runOnTCInit: <true | false>
    stopFunctionOnTCInit: <functionName>
  stackUsageOptions: 
  - coreId: <coreId>
    isActive: <true | false>
    baseAddr: <address>
    endAddr: <address>
    pattern: <bytePattern>
  - ...
  checkTargetState: <true | false>
  verifySymbolsBeforeRun: <true | false>

where:

version - contains version of testIDEA which was used for editing of the test specification file.
workspace - contains path to winIDEA project workspace file, which should be used for testing. If this tag is not present or contains an empty string, testIDEA connects to the most recently used winIDEA.
useQualifiedFuncName - used by testIDEA content proposal functionality. If set to true, download file name is shown next to function name.
address - specifies IP address or host name of machine running remote instance of winIDEA. If this tag is not present or contains an empty string, testIDEA connects to winIDEA on local host.
port - specifies port where remote instance of winIDEA is listening for connections. If this tag is not present or contains an empty string, testIDEA connects to winIDEA on default port.
coreIds - if target has more than one core, this list specifies string IDs for all cores. These IDs may be used in test cases to specify on which core to run the test. These IDs are testIDEA specific, so we can define some meaningful names here. The first element refers to core 0, the second to core 2, ...
autoConnect - if set to true, testIDEA automatically connects to winIDEA the first time it needs some data from it, for example when obtaining a list of functions. Otherwise it prompts user before connection is established.
autoIdFormat - this string can be used by test ID generator in testIDEA or scripts. See testIDEA online help for formats supported by testIDEA. If you implement your own test ID generator in Python script, you can define you own format.
defaultRetValName - this variable name is proposed by testIDEA as a name of the variable to contain the function return value when we are creating new test cases.
logFile - use this option only when instructed by iSYSTEM support.
initBeforeRun - if set to true, testIDEA always runs initialization sequence before starting tests. Otherwise is checks settings in the init sequence, and if the current target state does not match these settings, suggests the user to run the init sequence. For example, if init sequence requires to stop on function main, and target is not stopped on this function, then testIDEA will suggest running the init sequence.
disableInterrupts - if set to true, then testIDEA disables all interrupts on target before test.
testTimeout - defines maximum execution time for tests. After this timeout test is terminated by testIDEA. If not specified or 0, inifinte timeout is used. This setting may be overridden with timeout specified in test case - it is used only for test cases, where timeout is not specified.
breakpointType - defines which type of breakpoints should be used during testing.

keepWinIDEASetting - keep configuration from winIDEA.
useHWBreakpoints - use hardware breakpoints. Because the number of hardware breakpoints is limited, the number of stubs and test points is limited with this option.
useSWBreakpoints - use software breakpoints. Provides unlimited number of stubs and test points.
useHWBPsForInitThenSWBPs - use hardware breakpoints during target initialization, then switch to software breakpoints. Use this setting when target init code performs checksum of the code, but more stubs or test points are required than the number of available hardware breakpoints.

initSequence - this section defines actions for target initalization before test.
scriptConfig - this section contains configuration for script execution.
toolsConfig - this section configures wizards in testIDEA iTools menu.
evaluatorConfig - this section configures winIDEA evaluator. It defines format for values in winIDEA Watch window and testIDEA expression evaluation. Results of expression evaluation are stored in test reports.
testCaseTargetInit - this section defines target initialization steps to be executed before each test case.
stackUsageOptions - this section configures measurement of stack usage during tests for all target cores.
checkTargetState - if set to true, and stop function above is defined, then testIDEA checks if target is really stopped on the given function before test run, and pops-up a dialog if it is not stopped at the given function.
verifySymbolsBeforeRun - if set to true, testIDEA verifies symbols (global variables and functions) befor it runs tests. If any of symbols does not match, a warning dialog is popped-up.

Example(s):

version: 9.12.146
workspace: '/proj/demo/Sample5554.xjrf'
address: 192.168.1.10
stopFunction: main
defaultRetValName: retVal
port: 5333
autoIdFormat: /${uuid}/${params}

initSequence (isys::CInitSequenceAction)

This section defines actions for target initalization before test.

Syntax:

initSequence:
- coreId: <coreId>
  action: <connectToCore | download | reset | run | delAllBreakpoints | callTargetFunction | callScriptFunction | loadSymbolsOnly | waitUntilStopped>
  params: [<param0>, ...]
- ...

where:

coreId - ID of the core, where this action should be executed. If empty, core 0 is used.
action - specifies which action to execute.

connectToCore - makes connection to the specified core.
download - performs download.
reset - resets target.
run - runs target. Optionsl parameter may specify name of the function or label to run to.
delAllBreakpoints - deletes all break points on target.
callTargetFunction - calls function on target. Parameter defines function name.
callScriptFunction - calls script function. Parameter defines script function name.
loadSymbolsOnly - winIDEA only loads symbols from download file.
waitUntilStopped - waits until target stops, for example when running until function `main()`.

params - defines optional action parameters. See action descriptions above to see which actions need parameters.

scriptConfig (isys::CScriptConfig)

This section contains configuration for script execution.

Syntax:

scriptConfig:
  workingDir: <directory>
  modules: [<moduleName>, ...]
  sysPaths: [<sysPath>, ...]
  timeout: <timeInSeconds>
  extensionClass: <scriptClassName>

where:

workingDir - the working folder of Python interpreter, which runs test scripts. If empty, the folder of currently opened test specification file is used.
modules - the list of Python modules, which should be imported by testIDEA when running test scripts.
sysPaths - list of paths to add to Python's sys.path() for module loading. Required only if custom modules are used, which are not in one of Python's module search paths. If paths contain spaces or commas, they should be quoted!
timeout - defines how long testIDEA waits for script functions to return, in seconds. If any of the script functions does not return on time, the test is considered as failed.
extensionClass - name of the class which contains functions to be called during tests. The name should contain module name, for example 'myModule.myClass'. This is the singleton class for all test cases in the file.

Example(s):

scriptConfig: 
  workingDir: '/proj/myProject'
  modules: [sys, myModule]
  sysPaths: ['/proj/utils', '/lib/python']
  timeout: 10000
  extensionClass: myModule.myClass

toolsConfig (isys::CToolsConfig)

This section configures wizards in testIDEA iTools menu.

Syntax:

toolsConfig:
  isAutoSetAnalyzerFName: <true | false>
  analyzerFName: <fileName>
  isSetTestIdOnPaste: <true | false>

where:

isAutoSetAnalyzerFName - if true, then analyzer file name is automatically set when users activates analyzer in testIDEA.
analyzerFName - this setting defines analyzer file name to be used when automatically set by testIDEA. It may contain host variables, for example ${_testId}-${_function}.trd. See testIDEA content proposals for available host vars.
isSetTestIdOnPaste - if true, then testIDEA sets new test ID to pasted test cases. This way it is less likely that test IDs are duplicated.

evaluatorConfig (isys::CEvaluatorConfig)

This section configures winIDEA evaluator. It defines format for values in winIDEA Watch window and testIDEA expression evaluation. Results of expression evaluation are stored in test reports.

Syntax:

evaluatorConfig:
  isOverrideWinIDEASettings: <true | false>
  charDisplay: <ASCII | Integer | Both>
  isAnsiChar: <true | false>
  isHex: <true | false>
  binaryDisplay: <Blanks | NoBlanksTrailingB>
  isDisplayPointerMemArea: <true | false>
  isCharArrayAsString: <true | false>
  isDereferenceStringPointers: <true | false>
  addressDisplay: <HexNoPrefix | HexPrefix>
  enumDisplay: <Enum | Integer | Both>
  isDisplayCollapsedArrayStruct: <true | false>
  vagueFloatPrecision: <floatNumber>

where:

isOverrideWinIDEASettings - if true, then settings on this page are applied, otherwise the default winIDEA evaluator settings are used.
charDisplay - this setting defines display format for variables of type 'char':

ASCII - chars are displayed as ASCII characters
Integer - chars are displayed as integers
Both - chars are displayed as both ASCII characters and integers

isAnsiChar - if true, ANSI chars are displayed.
isHex - if true, integers are displayed in hex format.
binaryDisplay - this setting defines binary format:

Blanks - binary values are displayed as 11111111 00000000
NoBlanksTrailingB - binary values are displayed as 1111111100000000B

isDisplayPointerMemArea - if true, memory area is displayed in pointer prototypes.
isCharArrayAsString - if true, char arrays are displayed as zero terminated strings.
isDereferenceStringPointers - if true, dereferences 'char *' automatically.
addressDisplay - this setting defines address format:

HexNoPrefix - addresses are displayed as hex numbers without prefix
HexPrefix - addresses are displayed as hex numbers with '0x' prefix

enumDisplay - this setting defines enum format:

Enum - enum identifier is displayed
Integer - integer value is displayed
Both - enum identifier and integer value are displayed

isDisplayCollapsedArrayStruct - if true, array and structured type values are displayed.
vagueFloatPrecision - floating point numbers with difference less than this value are considered equal in testIDEA expressions.

Example(s):

evaluatorConfig: 
  isUseDefaultWinIDEASettings: false
  charDisplay: Both
  isAnsiChar: true
  isHex: true
  binaryDisplay: Blanks
  isDisplayPointerMemArea: true
  isCharArrayAsString: true
  isDereferenceStringPointers: true
  addressDisplay: HexPrefix
  enumDisplay: Both
  isDisplayCollapsedArrayStruct: false
  vagueFloatPrecision: 1e-5

testCaseTargetInit (isys::CTestCaseTargetInitConfig)

This section defines target initialization steps to be executed before each test case.

Syntax:

testCaseTargetInit:
  downloadOnTCInit: <true | false>
  resetOnTCInit: <true | false>
  runOnTCInit: <true | false>
  stopFunctionOnTCInit: <functionName>

where:

downloadOnTCInit - if this value is set to true, testIDEA will download code to the target before test case start.
resetOnTCInit - if this value is set to true, testIDEA will reset the target before test case start.
runOnTCInit - if this value is set to true, testIDEA will run the target before test case start (after the optional download or reset actions described above).
stopFunctionOnTCInit - if this section is defined and contains non-empty string, then testIDEA will set a breakpoint to the given function and wait until the target execution stops at the given function.

Example(s):

testCaseTargetInit:
  downloadOnTCInit: false
  resetOnTCInit: true
  runOnTCInit: true
  stopFunctionOnTCInit: main

stackUsageOptions (isys::CStackUsageConfig)

This section configures measurement of stack usage during tests for all target cores.

Syntax:

stackUsageOptions:
- coreId: <coreId>
  isActive: <true | false>
  baseAddr: <address>
  endAddr: <address>
  pattern: <bytePattern>
- ...

where:

coreId - id of core for which this stack usage constraints are specified.
isActive - if checked, stack area defined with base and end addresses below, is seeded with pattern before test run. This option must be selected, if you want to measure stack usage during tests. If it is not selected, winIDEA configuration is used (Debug | Debug Options ... | tab Stack Usage), and stack usage is only measured for test cases, which specify the limit.
baseAddr - The low address of stack area, the first one to be written with pattern. Enter hex value, decimal value, or label here.
endAddr - The high address of stack area + 1. It is no longer seeded with pattern: stack size = endAddr - baseAddr. Enter hex value, decimal value, or label here.
pattern - 8-bit value, which is written to stack area defined with base and end addresses above. Stack area, which contains other values after test, is considered by testIDEA as used stack memory. Enter hex or decimal value here.

Example(s):

stackUsageOptions:
- coreId: core-0
  isActive: true
  baseAddr: 0x4000f000
  endAddr: 0x4000fff0
  pattern: 0x55

reportConfig (isys::CTestReportConfig)

Contains configuration for test report generation.

Syntax:

reportConfig:
  testIDEAVersion: <version>
  winIDEAVersion: <version>
  reportContents: <full | errorsOnly>
  outFormat: <xml | yaml | csv | xls | xlsx>
  fileName: <fileName>
  iyamlFileName: <iyamlFileName>
  xsltFull: <fileName>
  xsltErrors: <fileName>
  xmlLogoImage: <>
  xmlReportHeader: <>
  cssFile: <>
  isEmbeddedXsltCss: <true | false>
  isCreateHtml: <true | false>
  csvSeparator: <char>
  isCSVHeaderLine: <true | false>
  isXLSVerticalHeader: <true | false>
  isIncludeTestSpec: <true | false>
  isAbsPathForLinks: <true | false>
  htmlViewMode: <all | errorsOnly>
  testInfo: {<key>: <value>, ...}
  useCustomTime: <true | false>

where:

testIDEAVersion - this field is configured automatically when running tests with current testIDEA version.
winIDEAVersion - this field is configured automatically when running tests with current winIDEA version
reportContents - This field defines how detailed test report should be.

full - report will contain all measured values from profiler of coverage sections.
errorsOnly - report will contain only those measured values, which have caused the test to fail.

outFormat - Defines format of test report file.

xml - save in XML format.
yaml - save in YAML format.
csv - save in CSV format.
xls - save in old Excel format.
xlsx - save in new Excel format.

fileName - name of test report file.
iyamlFileName - name of test specification file which was used to generate report.
xsltFull - name of XSLT file used for full reports
xsltErrors - deprecated, no longer used
xmlLogoImage - file name of image (company logo) to be used in test report
xmlReportHeader - text to be used for test report header
cssFile - CSS file to be used for report rendering
isEmbeddedXsltCss - if true, XSLT and CSS files are embedded into XML file. Please note that Internet Explorer and Edge do not render such files properly.
isCreateHtml - if true, report in HTML format is also created. This way report generation does not depend on browser XSLT implementation.
csvSeparator - separator used in CSV format
isCSVHeaderLine - if true, header line is written to CSV file
isXLSVerticalHeader - if true, column headers in XLS and XLSX formats are written vertically
isIncludeTestSpec - if true, complete test specification in YAML format is included in test report of each test
isAbsPathForLinks - if false, relative paths to analyzer export files are converted to absolute ones in test report.
htmlViewMode - defines which information to show in HTML view of the XML report file.

all - results of all test cases are shown.
errorsOnly - only results of test cases with error are shown

testInfo - mapping of key/value pairs with custom information to be stored to test report
useCustomTime - deprecated, use custom settings

Example(s):

reportConfig:
  winIDEAVersion: 9.12.145
  reportContents: full
  outFormat: xml
  fileName: 'd:/tmp/reportFull.xml'
  xsltFull: ' itestResult.blue.xslt'
  xsltErrors: ' itestErrors.gray.xslt'
  csvSeparator: ','
  isCSVHeaderLine: true
  isXLSVerticalHeader: false
  isIncludeTestSpec: true
  useCustomTime: false
  isAbsPathForLinks: true
  testInfo:
    tester: markok
    winIDEAVersion: 9.12.45
    date: 
    time:

testFilters (isys::CTestFilter)

Contains filtes for test execution.

Syntax:

testFilters:
- filterId: <>
  type: <builtIn | script>
  coreId: <>
  partitions: [<partition>, ...]
  modules: [<>, ...]
  includedIds: [<testId>, ...]
  excludedIds: [<testId>, ...]
  includedFunctions: [<functionName>, ...]
  excludedFunctions: [<functionName>, ...]
  mustHaveAllTags: [<tag>, ...]
  mustHaveOneOfTags: [<tag>, ...]
  mustNotHaveAllTags: [<tag>, ...]
  mustNotHaveOneOfTags: [<tag>, ...]
  isOr1: <true | false>
  isOr2: <true | false>
  isOr3: <true | false>
  scriptFunction: <scriptFunctionName>
  scriptFunctionParams: [<scriptFunctionParam>, ...]
- ...

where:

filterId - unique filter name
type - defines which kind of filtering is used

builtIn - filter built into testIDEA is used
script - filter implemented in Python script is used

coreId - one of core IDs as specified in CTestEnvironmentConfig.coreIds. Empty string means default core (the first in the list of core IDs).
partitions - list of download files, which should pass this filter. Empty string means that all download files pass.
modules - list of source files, which should pass this filter. Empty string means that all source files pass.
includedIds - Test specs with IDs specified in this field are executed regardless of their tags and excluded IDs.
excludedIds - Test specs with IDs specified in this field are NOT executed regardless of their tags.
includedFunctions - Test specs for functions specified in this field are executed regardless of any other setting.
excludedFunctions - Test specs for functions specified in this field are NOT executed regardless of any other setting.
mustHaveAllTags - list of tags, which test case must have defined to be excuted
mustHaveOneOfTags - at least one of these tags must be defined in test case to be executed
mustNotHaveAllTags - none of these tags may be present in test case to be executed
mustNotHaveOneOfTags - at lest one of these tags must not be present in test case to be executed
isOr1 - if true, logical operation between conditions 'mustHaveAllTags' and 'mustHaveOneOfTags' is OR, AND otherwise
isOr2 - if true, logical operation between conditions 'mustHaveOneOfTags' and 'mustNotHaveAllTags' is OR, AND otherwise
isOr3 - if true, logical operation between conditions 'mustNotHaveAllTags' and 'mustNotHaveOneOfTags' is OR, AND otherwise
scriptFunction - Name of the script function to use for test filtering.The function should return 'true' if test specification should be executed.
scriptFunctionParams - Comma separated list of parameters for the script function.

Example(s):

testFilters:
- filterId: filterA
  type: script
  mustHaveAllTags: [asd]
  mustHaveOneOfTags: [sdfgh]
  isOr1: false
  isOr2: false
  isOr3: false
  scriptFunction: filterHasParams
  scriptFunctionParams: [_isys_testSpec, 1]
- filterId: filterB
  isOr1: false
  isOr2: false
  isOr3: false
  includedIds: [two]
  excludedIds: [three]
  excludedFunctions: [Func4]

groups (isys::CTestGroup)

Contains a list of test groups. Each test group shows test cases, which pass filter specified in the group.

Syntax:

groups:
  id: <>
  isExecute: <true | false>
  desc: <text>
  filter: 
    filterId: <>
    type: <builtIn | script>
    coreId: <>
    partitions: [<partition>, ...]
    modules: [<>, ...]
    includedIds: [<testId>, ...]
    excludedIds: [<testId>, ...]
    includedFunctions: [<functionName>, ...]
    excludedFunctions: [<functionName>, ...]
    mustHaveAllTags: [<tag>, ...]
    mustHaveOneOfTags: [<tag>, ...]
    mustNotHaveAllTags: [<tag>, ...]
    mustNotHaveOneOfTags: [<tag>, ...]
    isOr1: <true | false>
    isOr2: <true | false>
    isOr3: <true | false>
    scriptFunction: <scriptFunctionName>
    scriptFunctionParams: [<scriptFunctionParam>, ...]
  mergedAnalyzerFile: <fileName.trd>
  isCloseAfterTest: <true | false>
  coverageExport: 
    isActive: <true | false>
    isMeasureAllFunctions: <true | false>
    isIgnoreNonReachableCode: <true | false>
    mergeScope: <none | siblingsOnly | siblingsAndParent | all>
    mergeFilter: 
      filterId: <>
      type: <builtIn | script>
      coreId: <>
      partitions: [<partition>, ...]
      modules: [<>, ...]
      includedIds: [<testId>, ...]
      excludedIds: [<testId>, ...]
      includedFunctions: [<functionName>, ...]
      excludedFunctions: [<functionName>, ...]
      mustHaveAllTags: [<tag>, ...]
      mustHaveOneOfTags: [<tag>, ...]
      mustNotHaveAllTags: [<tag>, ...]
      mustNotHaveOneOfTags: [<tag>, ...]
      isOr1: <true | false>
      isOr2: <true | false>
      isOr3: <true | false>
      scriptFunction: <scriptFunctionName>
      scriptFunctionParams: [<scriptFunctionParam>, ...]
    exportFormat: <HTML | Text | CSV | XML | Review (HTML) | Review (Text)>
    formatVariant: <variantName>
    exportFile: <fileName>
    isAssemblerInfo: <true | false>
    isLaunchViewer: <true | false>
    isExportModuleLines: <true | false>
    isExportSources: <true | false>
    isExportFunctionLines: <true | false>
    isExportAsm: <true | false>
    isExportRanges: <true | false>
    exportFunctionsFilter: <functionName>
    exportModulesFilter: <moduleName>
    statistics: 
    - func: <functionName>
      code: <percentage>
      sourceLines: <percentage>
      branches: <percentage>
      taken: <percentage>
      notTaken: <percentage>
      both: <percentage>
      execCount: <>
    - ...
  coverageAllCodeInGroup: 
    func: <functionName>
    code: <percentage>
    sourceLines: <percentage>
    branches: <percentage>
    taken: <percentage>
    notTaken: <percentage>
    both: <percentage>
    execCount: <>
  coverageTestCasesOnly: 
    func: <functionName>
    code: <percentage>
    sourceLines: <percentage>
    branches: <percentage>
    taken: <percentage>
    notTaken: <percentage>
    both: <percentage>
    execCount: <>
  initScriptFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  endScriptFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  children: 
  - 
  - ...

where:

id - This section defines group id. It is used in reports.It may contain only alphanumeric charaters or one of '.', '/', or '-'. It must start with a letter or underscore. This item is optional - it helps you to know which test results were produced by which test group. It is recommended to use unique ID for each group, but isystem.test does not enforce it.
isExecute - if true test cases in this group are executed, otherwise not.
desc - this section can be used for test documentation.
filter - this section defines filtering criteria for test cases. All test cases, which pass the filter, are members of this group.
mergedAnalyzerFile - name of analyzer file, which will contain merged analyzer files of all test cases, which are members of this group.
isCloseAfterTest - if true, the merged analyzer file is closed after merging. It is better for performance if there are not too many analyzer files opened in winIDEA.
coverageExport - this section defines export parameters for the merged analyzer file. Section for coverage merging is ignored.
coverageAllCodeInGroup - coverage criteria for all functions in the group. For example, if group specifies a module names as filter, then all functions in this module make 100%.
coverageTestCasesOnly - coverage criteria for all test cases in the group. Functions tested by test cases in group make 100%.
initScriptFunc - script function to be called, before any test case executes.
endScriptFunc - script function to be called, after all test cases execute.
children - child groups, input to their filters are only test cases which pass filter of parent groups.

filter (isys::CTestFilter)

This section defines filtering criteria for test cases. All test cases, which pass the filter, are members of this group.

Syntax:

filter:
  filterId: <>
  type: <builtIn | script>
  coreId: <>
  partitions: [<partition>, ...]
  modules: [<>, ...]
  includedIds: [<testId>, ...]
  excludedIds: [<testId>, ...]
  includedFunctions: [<functionName>, ...]
  excludedFunctions: [<functionName>, ...]
  mustHaveAllTags: [<tag>, ...]
  mustHaveOneOfTags: [<tag>, ...]
  mustNotHaveAllTags: [<tag>, ...]
  mustNotHaveOneOfTags: [<tag>, ...]
  isOr1: <true | false>
  isOr2: <true | false>
  isOr3: <true | false>
  scriptFunction: <scriptFunctionName>
  scriptFunctionParams: [<scriptFunctionParam>, ...]

where:

filterId - unique filter name
type - defines which kind of filtering is used

builtIn - filter built into testIDEA is used
script - filter implemented in Python script is used

coreId - one of core IDs as specified in CTestEnvironmentConfig.coreIds. Empty string means default core (the first in the list of core IDs).
partitions - list of download files, which should pass this filter. Empty string means that all download files pass.
modules - list of source files, which should pass this filter. Empty string means that all source files pass.
includedIds - Test specs with IDs specified in this field are executed regardless of their tags and excluded IDs.
excludedIds - Test specs with IDs specified in this field are NOT executed regardless of their tags.
includedFunctions - Test specs for functions specified in this field are executed regardless of any other setting.
excludedFunctions - Test specs for functions specified in this field are NOT executed regardless of any other setting.
mustHaveAllTags - list of tags, which test case must have defined to be excuted
mustHaveOneOfTags - at least one of these tags must be defined in test case to be executed
mustNotHaveAllTags - none of these tags may be present in test case to be executed
mustNotHaveOneOfTags - at lest one of these tags must not be present in test case to be executed
isOr1 - if true, logical operation between conditions 'mustHaveAllTags' and 'mustHaveOneOfTags' is OR, AND otherwise
isOr2 - if true, logical operation between conditions 'mustHaveOneOfTags' and 'mustNotHaveAllTags' is OR, AND otherwise
isOr3 - if true, logical operation between conditions 'mustNotHaveAllTags' and 'mustNotHaveOneOfTags' is OR, AND otherwise
scriptFunction - Name of the script function to use for test filtering.The function should return 'true' if test specification should be executed.
scriptFunctionParams - Comma separated list of parameters for the script function.

Example(s):

testFilters:
- filterId: filterA
  type: script
  mustHaveAllTags: [asd]
  mustHaveOneOfTags: [sdfgh]
  isOr1: false
  isOr2: false
  isOr3: false
  scriptFunction: filterHasParams
  scriptFunctionParams: [_isys_testSpec, 1]
- filterId: filterB
  isOr1: false
  isOr2: false
  isOr3: false
  includedIds: [two]
  excludedIds: [three]
  excludedFunctions: [Func4]

coverageExport (isys::CTestAnalyzerCoverage)

This section defines export parameters for the merged analyzer file. Section for coverage merging is ignored.

Syntax:

coverageExport:
  isActive: <true | false>
  isMeasureAllFunctions: <true | false>
  isIgnoreNonReachableCode: <true | false>
  mergeScope: <none | siblingsOnly | siblingsAndParent | all>
  mergeFilter: 
    filterId: <>
    type: <builtIn | script>
    coreId: <>
    partitions: [<partition>, ...]
    modules: [<>, ...]
    includedIds: [<testId>, ...]
    excludedIds: [<testId>, ...]
    includedFunctions: [<functionName>, ...]
    excludedFunctions: [<functionName>, ...]
    mustHaveAllTags: [<tag>, ...]
    mustHaveOneOfTags: [<tag>, ...]
    mustNotHaveAllTags: [<tag>, ...]
    mustNotHaveOneOfTags: [<tag>, ...]
    isOr1: <true | false>
    isOr2: <true | false>
    isOr3: <true | false>
    scriptFunction: <scriptFunctionName>
    scriptFunctionParams: [<scriptFunctionParam>, ...]
  exportFormat: <HTML | Text | CSV | XML | Review (HTML) | Review (Text)>
  formatVariant: <variantName>
  exportFile: <fileName>
  isAssemblerInfo: <true | false>
  isLaunchViewer: <true | false>
  isExportModuleLines: <true | false>
  isExportSources: <true | false>
  isExportFunctionLines: <true | false>
  isExportAsm: <true | false>
  isExportRanges: <true | false>
  exportFunctionsFilter: <functionName>
  exportModulesFilter: <moduleName>
  statistics: 
  - func: <functionName>
    code: <percentage>
    sourceLines: <percentage>
    branches: <percentage>
    taken: <percentage>
    notTaken: <percentage>
    both: <percentage>
    execCount: <>
  - ...

where:

isActive - if true, coverage is recorded
isMeasureAllFunctions - if true, coverage of all function is recorded, not only of those added in statistics section.
isIgnoreNonReachableCode - This setting is passed to winIDEA analyzer configuration.
mergeScope - this section define merging scope.

none - no merging is performed.
siblingsOnly - only siblings of this test case, which have already been executed, are used as filter input.
siblingsAndParent - only siblings and parent of this test case, which have already been executed, are used as filter input.
all - all test cases which have been executed up to this point are used as filter input

mergeFilter - this section define merging filter. If empty, no tests are excluded.
exportFormat - name of the export format.

HTML - specifies HTML export format.
Text - specifies text export format.
CSV - specifies CSV export format.
XML - specifies XML export format.
Review (HTML) - deprecated.
Review (Text) - deprecated.

formatVariant - variant of the export format, usually empty.
exportFile - if this item is defined, coverage results are exported to file with this name in format specified by exportFormat.
isAssemblerInfo - if true, information about assembly level coverage will be provided.
isLaunchViewer - default system viewer for exported files will be launched after export.
isExportModuleLines - if true, lines coverage for modules will be exported.
isExportSources - source line coverage will be exported. It contains the sameinformation with markers as shown in winDIDEA source file.
isExportFunctionLines - if true, lines coverage for modules will be exported.
isExportAsm - coverage of assembler level instructions will be exported.
isExportRanges - coverage of ranges without source info will be exported.
exportFunctionsFilter - filter for functions to be exported.
exportModulesFilter - filter for modules to be exported.
statistics - this section contains coverage statistics criteria.

Example(s):

    coverage:
      isActive: true
      exportFormat: HTML
      exportFile: testExport.html
      statistics:
      - func: max_int
        code: 96
        sourceLines: 85
        branches: 100
        notTaken: 100

mergeFilter (isys::CTestFilter)

This section define merging filter. If empty, no tests are excluded.

Syntax:

mergeFilter:
  filterId: <>
  type: <builtIn | script>
  coreId: <>
  partitions: [<partition>, ...]
  modules: [<>, ...]
  includedIds: [<testId>, ...]
  excludedIds: [<testId>, ...]
  includedFunctions: [<functionName>, ...]
  excludedFunctions: [<functionName>, ...]
  mustHaveAllTags: [<tag>, ...]
  mustHaveOneOfTags: [<tag>, ...]
  mustNotHaveAllTags: [<tag>, ...]
  mustNotHaveOneOfTags: [<tag>, ...]
  isOr1: <true | false>
  isOr2: <true | false>
  isOr3: <true | false>
  scriptFunction: <scriptFunctionName>
  scriptFunctionParams: [<scriptFunctionParam>, ...]

where:

filterId - unique filter name
type - defines which kind of filtering is used

builtIn - filter built into testIDEA is used
script - filter implemented in Python script is used

coreId - one of core IDs as specified in CTestEnvironmentConfig.coreIds. Empty string means default core (the first in the list of core IDs).
partitions - list of download files, which should pass this filter. Empty string means that all download files pass.
modules - list of source files, which should pass this filter. Empty string means that all source files pass.
includedIds - Test specs with IDs specified in this field are executed regardless of their tags and excluded IDs.
excludedIds - Test specs with IDs specified in this field are NOT executed regardless of their tags.
includedFunctions - Test specs for functions specified in this field are executed regardless of any other setting.
excludedFunctions - Test specs for functions specified in this field are NOT executed regardless of any other setting.
mustHaveAllTags - list of tags, which test case must have defined to be excuted
mustHaveOneOfTags - at least one of these tags must be defined in test case to be executed
mustNotHaveAllTags - none of these tags may be present in test case to be executed
mustNotHaveOneOfTags - at lest one of these tags must not be present in test case to be executed
isOr1 - if true, logical operation between conditions 'mustHaveAllTags' and 'mustHaveOneOfTags' is OR, AND otherwise
isOr2 - if true, logical operation between conditions 'mustHaveOneOfTags' and 'mustNotHaveAllTags' is OR, AND otherwise
isOr3 - if true, logical operation between conditions 'mustNotHaveAllTags' and 'mustNotHaveOneOfTags' is OR, AND otherwise
scriptFunction - Name of the script function to use for test filtering.The function should return 'true' if test specification should be executed.
scriptFunctionParams - Comma separated list of parameters for the script function.

Example(s):

testFilters:
- filterId: filterA
  type: script
  mustHaveAllTags: [asd]
  mustHaveOneOfTags: [sdfgh]
  isOr1: false
  isOr2: false
  isOr3: false
  scriptFunction: filterHasParams
  scriptFunctionParams: [_isys_testSpec, 1]
- filterId: filterB
  isOr1: false
  isOr2: false
  isOr3: false
  includedIds: [two]
  excludedIds: [three]
  excludedFunctions: [Func4]

statistics (isys::CTestCoverageStatistics)

This section contains coverage statistics criteria.

Syntax:

statistics:
- func: <functionName>
  code: <percentage>
  sourceLines: <percentage>
  branches: <percentage>
  taken: <percentage>
  notTaken: <percentage>
  both: <percentage>
  execCount: <>
- ...

where:

func - name of the function, for which we want to measure coverage. Required.
code - required minimum of code coverage in percents
sourceLines - required minimum of source lines coverage in percents
branches - required minimum of branches covered in percents
taken - required minimum of taken branches in percents
notTaken - required minimum of not taken branches in percents
both - required minimum of both branches in percents
execCount - number of executions

coverageAllCodeInGroup (isys::CTestCoverageStatistics)

Coverage criteria for all functions in the group. For example, if group specifies a module names as filter, then all functions in this module make 100%.

Syntax:

coverageAllCodeInGroup:
  func: <functionName>
  code: <percentage>
  sourceLines: <percentage>
  branches: <percentage>
  taken: <percentage>
  notTaken: <percentage>
  both: <percentage>
  execCount: <>

where:

func - name of the function, for which we want to measure coverage. Required.
code - required minimum of code coverage in percents
sourceLines - required minimum of source lines coverage in percents
branches - required minimum of branches covered in percents
taken - required minimum of taken branches in percents
notTaken - required minimum of not taken branches in percents
both - required minimum of both branches in percents
execCount - number of executions

coverageTestCasesOnly (isys::CTestCoverageStatistics)

Coverage criteria for all test cases in the group. Functions tested by test cases in group make 100%.

Syntax:

coverageTestCasesOnly:
  func: <functionName>
  code: <percentage>
  sourceLines: <percentage>
  branches: <percentage>
  taken: <percentage>
  notTaken: <percentage>
  both: <percentage>
  execCount: <>

where:

func - name of the function, for which we want to measure coverage. Required.
code - required minimum of code coverage in percents
sourceLines - required minimum of source lines coverage in percents
branches - required minimum of branches covered in percents
taken - required minimum of taken branches in percents
notTaken - required minimum of not taken branches in percents
both - required minimum of both branches in percents
execCount - number of executions

initScriptFunc (isys::CTestFunction)

Script function to be called, before any test case executes.

Syntax:

initScriptFunc:
  func: <functionName>
  params: [<parameter>, ...]
  retVal: <varName>

where:

func - name of function
params - parameters
retVal - name of variable to be used to store function return value. Used only for function under test, ignored for script functions.

Example(s):

    func:
      func: min_int
      params:
      - 4
      - 9
      retVal: rv

    func: [min_int, [4, 9], rv]
    expect: [rv == 4]

endScriptFunc (isys::CTestFunction)

Script function to be called, after all test cases execute.

Syntax:

endScriptFunc:
  func: <functionName>
  params: [<parameter>, ...]
  retVal: <varName>

where:

func - name of function
params - parameters
retVal - name of variable to be used to store function return value. Used only for function under test, ignored for script functions.

Example(s):

    func:
      func: min_int
      params:
      - 4
      - 9
      retVal: rv

    func: [min_int, [4, 9], rv]
    expect: [rv == 4]

testCases (isys::CTestSpecification)

Contains a list of test cases.

Syntax:

testCases:
  id: <>
  testScope: <unitTest | systemTest>
  baseId: <>
  run: <true | false>
  imports: 
    id: 
      inherit: <true | false>
      ids: [<testId>, ...]
    scope: 
      inherit: <true | false>
      ids: [<testId>, ...]
    desc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    tags: 
      inherit: <true | false>
      ids: [<testId>, ...]
    options: 
      inherit: <true | false>
      ids: [<testId>, ...]
    persistVars: 
      inherit: <true | false>
      ids: [<testId>, ...]
    locals: 
      inherit: <true | false>
      ids: [<testId>, ...]
    init: 
      inherit: <true | false>
      ids: [<testId>, ...]
    beginStopCondition: 
      inherit: <true | false>
      ids: [<testId>, ...]
    endStopCondition: 
      inherit: <true | false>
      ids: [<testId>, ...]
    func: 
      inherit: <true | false>
      ids: [<testId>, ...]
    testTimeout: 
      inherit: <true | false>
      ids: [<testId>, ...]
    coreId: 
      inherit: <true | false>
      ids: [<testId>, ...]
    initTargetFunc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    initFunc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    endFunc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    restoreTargetFunc: 
      inherit: <true | false>
      ids: [<testId>, ...]
    stubs: 
      inherit: <true | false>
      ids: [<testId>, ...]
    userStubs: 
      inherit: <true | false>
      ids: [<testId>, ...]
    testPoints: 
      inherit: <true | false>
      ids: [<testId>, ...]
    preCondition: 
      inherit: <true | false>
      ids: [<testId>, ...]
    assert: 
      inherit: <true | false>
      ids: [<testId>, ...]
    stackUsage: 
      inherit: <true | false>
      ids: [<testId>, ...]
    log: 
      inherit: <true | false>
      ids: [<testId>, ...]
    analyzer: 
      inherit: <true | false>
      ids: [<testId>, ...]
    hil: 
      inherit: <true | false>
      ids: [<testId>, ...]
    dryRun: 
      inherit: <true | false>
      ids: [<testId>, ...]
    diagrams: 
      inherit: <true | false>
      ids: [<testId>, ...]
    params: 
      inherit: <true | false>
      ids: [<testId>, ...]
  desc: <text>
  tags: [<tag>, ...]
  options: {<winIDEAOptionPath>: <optionValue>, ...}
  persistVars: 
    decl: {<varName>: <varType>, ...}
    delete: [<varName>, ...]
    isDeleteAll: <true | false>
  locals: {<varName>: <varType>, ...}
  init: {<varName>: <varValue>, ...}
  beginStopCondition: 
    stopType: <breakpoint | stop | rtExpression | noRun>
    timeout: <milliseconds>
    rtExpression: <expression>
    conditionCount: <count>
    conditionExpr: <expression>
    bpLocation: 
      resourceType: <function | file | address>
      resourceName: <fileName or functionName>
      srcFileLocation: <localHost | winIDEAHost>
      line: <number>
      isSearch: <true | false>
      linesRange: <number>
      searchContext: <any | code | comment>
      matchType: <plain | regEx | testPointId>
      pattern: <pattern>
      lineOffset: <number>
      numSteps: <number>
  endStopCondition: 
    stopType: <breakpoint | stop | rtExpression | noRun>
    timeout: <milliseconds>
    rtExpression: <expression>
    conditionCount: <count>
    conditionExpr: <expression>
    bpLocation: 
      resourceType: <function | file | address>
      resourceName: <fileName or functionName>
      srcFileLocation: <localHost | winIDEAHost>
      line: <number>
      isSearch: <true | false>
      linesRange: <number>
      searchContext: <any | code | comment>
      matchType: <plain | regEx | testPointId>
      pattern: <pattern>
      lineOffset: <number>
      numSteps: <number>
  func: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  testTimeout: <timeout>
  coreId: <coreId>
  initTargetFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  initFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  endFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  restoreTargetFunc: 
    func: <functionName>
    params: [<parameter>, ...]
    retVal: <varName>
  stubs: 
  - stubbedFunc: <functionName>
    isActive: <true | false>
    isCustomActivation: <true | false>
    params: [<parameter>, ...]
    retValName: <varName>
    scriptFunc: <functionName>
    hitLimits: 
      min: <numHits>
      max: <numHits>
    log: 
      before: [<varName>, ...]
      after: [<varName>, ...]
    assignSteps: 
    - expect: [<expression>, ...]
      assign: {<varName>: <varValue>, ...}
      scriptParams: [<parameter>, ...]
      next: <index>
    - ...
  - ...
  userStubs: 
  - func: <functionName>
    isActive: <true | false>
    replacementFunc: <functionName>
  - ...
  testPoints: 
  - tpId: <>
    isActive: <true | false>
    isCustomActivation: <true | false>
    conditionCount: <count>
    conditionExpr: <expression>
    scriptFunc: <functonName>
    location: 
      resourceType: <function | file | address>
      resourceName: <fileName or functionName>
      srcFileLocation: <localHost | winIDEAHost>
      line: <number>
      isSearch: <true | false>
      linesRange: <number>
      searchContext: <any | code | comment>
      matchType: <plain | regEx | testPointId>
      pattern: <pattern>
      lineOffset: <number>
      numSteps: <number>
    log: 
      before: [<varName>, ...]
      after: [<varName>, ...]
    hitLimits: 
      min: <numHits>
      max: <numHits>
    steps: 
    - expect: [<expression>, ...]
      assign: {<varName>: <varValue>, ...}
      scriptParams: [<parameter>, ...]
      next: <index>
    - ...
  - ...
  preCondition: 
    isExpectException: <true | false>
    expressions: [<C expression>, ...]
  assert: 
    isExpectException: <true | false>
    expressions: [<C expression>, ...]
  stackUsage: 
    minLimit: <numBytes>
    maxLimit: <numBytes>
  log: 
    before: [<varName>, ...]
    after: [<varName>, ...]
  analyzer: 
    runMode: <off | start>
    document: <fileName>
    openMode: <u | w | a>
    isSlowRun: <true | false>
    trigger: <triggerName>
    isPredefTrigger: <true | false>
    isSaveAfterTest: <true | false>
    isCloseAfterTest: <true | false>
    trace: 
      isActive: <true | false>
      exportFormat: <Text | CSV | Binary | XML>
      exportFile: <fileName>
    coverage: 
      isActive: <true | false>
      isMeasureAllFunctions: <true | false>
      isIgnoreNonReachableCode: <true | false>
      mergeScope: <none | siblingsOnly | siblingsAndParent | all>
      mergeFilter: 
        filterId: <>
        type: <builtIn | script>
        coreId: <>
        partitions: [<partition>, ...]
        modules: [<>, ...]
        includedIds: [<testId>, ...]
        excludedIds: [<testId>, ...]
        includedFunctions: [<functionName>, ...]
        excludedFunctions: [<functionName>, ...]
        mustHaveAllTags: [<tag>, ...]
        mustHaveOneOfTags: [<tag>, ...]
        mustNotHaveAllTags: [<tag>, ...]
        mustNotHaveOneOfTags: [<tag>, ...]
        isOr1: <true | false>
        isOr2: <true | false>
        isOr3: <true | false>
        scriptFunction: <scriptFunctionName>
        scriptFunctionParams: [<scriptFunctionParam>, ...]
      exportFormat: <HTML | Text | CSV | XML | Review (HTML) | Review (Text)>
      formatVariant: <variantName>
      exportFile: <fileName>
      isAssemblerInfo: <true | false>
      isLaunchViewer: <true | false>
      isExportModuleLines: <true | false>
      isExportSources: <true | false>
      isExportFunctionLines: <true | false>
      isExportAsm: <true | false>
      isExportRanges: <true | false>
      exportFunctionsFilter: <functionName>
      exportModulesFilter: <moduleName>
      statistics: 
      - func: <functionName>
        code: <percentage>
        sourceLines: <percentage>
        branches: <percentage>
        taken: <percentage>
        notTaken: <percentage>
        both: <percentage>
        execCount: <>
      - ...
    profiler: 
      isActive: <true | false>
      isMeasureAllFunctions: <true | false>
      exportFormat: <Text | XML | CSV | Text1 | XMLBinaryTimeline | BTF | MDF>
      exportFile: <>
      isExportActiveOnly: <true | false>
      isProfileAUX: <true | false>
      isSaveHistory: <true | false>
      codeAreas: 
      - name: <funcName or varName>
        value: <stateValue>
        netTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        grossTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        callTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        periodTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        outsideTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        hits: [<number>, ...]
      - ...
      dataAreas: 
      - name: <funcName or varName>
        value: <stateValue>
        netTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        grossTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        callTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        periodTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        outsideTime: 
          min: [<lowerBound>, <upperBound>]
          minStart: [<lowerBound>, <upperBound>]
          minEnd: [<lowerBound>, <upperBound>]
          max: [<lowerBound>, <upperBound>]
          maxStart: [<lowerBound>, <upperBound>]
          maxEnd: [<lowerBound>, <upperBound>]
          total: [<lowerBound>, <upperBound>]
          average: [<lowerBound>, <upperBound>]
        hits: [<number>, ...]
      - ...
  hil: 
    params: {<hilParamName>: <hilParamValue>, ...}
  dryRun: 
    assign: {<hostVarName>: <expression>, ...}
    isUpdateCoverage: <true | false>
    isUpdateProfiler: <true | false>
    profilerMultiplier: <>
    profilerOffset: <>
  diagrams: 
    isActive: <true | false>
    diagrams: 
    - isActive: <true | false>
      diagramType: <flowChart | sequenceDiagram | callGraph | staticCallGraph | flameGraph | custom | customAsync>
      script: <scriptName.py>
      params: [<arg1>, ...]
      outFile: <fileName>
      isAddToReport: <true | false>
      viewer: <multiPage | singlePage | externalApp | none>
      dataFormat: <byExtension | bitmap | SVG>
      externalViewer: <pathToApp>
    - ...
  tests: 
  - 
  - ...

where:

id - This section defines test id. It is used for reports and filtering. It may contain only alphanumeric charaters or one of '.', '/', or '-'. It must start with a letter or underscore. This item is optional - it helps you to know which test result has been produced by which test specification. It is recommended to use unique ID for each test, but isystem.test does not enforce it.
testScope - defines whether this test tests single function (unit) or some other parts of the system.

unitTest - function will be tested, see section 'func' for function name and parameters
systemTest - other parts of system will be tested, see sections 'beginStopCondition' and 'endStopCondition'.

baseId - This section refers to the id of the parant of this test specification. It is used only when parsing test specs from non-iyaml files, for example C/C++ source files, where the test spec tree structure must be explicitly defined. After the test spec tree is build in the phase after parsing, this tag is no longer used. This tag is ignored in normal iyaml files.
run - Specifies if the test should be executed or not. If not specified, it is set to true by default. We may want to turn the execution off for base tests, if they only contain data used by derived tests.
imports - defines inheritance for all other sections. This section is never inherited from base test case.
desc - this section can be used for test documentation.
tags - This section contains list of tags, which can be used for test filtering by test suite. Tag may contain only alphanumeric charaters and underscore. It must start with a letter or underscore. Tags are separated by commas.
options - defines options for winIDEA configuration. See winIDEA Help | Display Options ... for the list of available options.
persistVars - this section manages variables, which have lifetime of more than one test case. If you need variables for one test only, use test local variables.
locals - this section defines local variables, which may be used as parameters when calling the tested function. This is required, when the function expects parameters as pointers or references.
- varName - name of the declared variable
- varType - type of the declared variable. Only types declared in the target application and available in debug info may be used.
If is the same as an existing (global) variable name, then the existing variables are shadowed.
init - this section initializes variables declared in the locals section, global variables, registers, and persistent variables.
beginStopCondition - this section defines where the target should stop before test is started.
endStopCondition - this section defines where the target should stop to finish the test.
func - this section specifies the function to be tested in unit tests. It can be written as mapping as shown below, but also as list: [, [, ...], ]. Always use mapping form when writing comments to sections.
testTimeout - specifies when to terminate test case if it does not end normally. If this value is 0, infinite timeout is used. If this value is not set (the field is empty) then global test timeout is used (see section env.testTimeout).
coreId - specifies ID of the core, where this test case should be executed. See env.coreIds for list of coreIDs.
initTargetFunc - this section specifies which script function should be called to initialize the target before test.
initFunc - this section specifies which script function should be called before the tested function is called. Local test variables are already created and initialized at this time. Trace, profiler, and coverage are also initialized according to specification.
This function may be used for additional target initialization or initialization of complex variables (arrays and structures).
endFunc - this section specifies which script function should be called after the tested function returns. It can be used for complex text verifications, which can not be described by YAML test specfication.
For example, contents of arrays may be verified using this function, or additional data retrieved from trace, coverage or profiler.
restoreTargetFunc - this section specifies which function in the test suite should be called after the test ends. It can be used to restore target state after the test, usually to revert changes done in initTargetFunc.
For example, global variables may be restored.
stubs - this section defines which functions called by the function under test should be stubbed. This means, that stubbed functions are not executed, while their side effects are simulated. For example, the return value and global variables are set. It is also possible to specify the script extension method to be called, when the stub is hit.
userStubs - this section defines which functions called by the function under test should be stubbed. This means, that stubbed functions are not executed. Instead we can define immediate return (for void functions) or replacement function implemented on target.
testPoints - this section defines arbitrary points in source code, where target state (variable values, registers, ...) can be logged, changed or verified.
preCondition - this section specifies conditions to be fulfilled before the test starts. Conditions are specified as expressions, which must evaluate to true.
assert - this section specifies expected outcome of test regarding target exceptions and values of variables, registers, ...
stackUsage - this section defines the limits for stack used by current test case.
log - this section defines setting for logging of values before and after test.
analyzer - this section defines setting for coverage, profiler, and trace.
hil - this section contains HIL configuration to be applied before test starts.
dryRun - this section contains assignments to be copied to section 'init' during Dry Run.
diagrams - this section contains specification for test output diagrams.
tests - this section contains derived test cases.

Example(s):

id: test_00023
desc: This test verifies function timings.
tags: nightly, unit, systemA
run: false
locals:
  a: MyStruct
  index: int
  arr: int[10]
init:
  a.x: 10
  a.y: 20
  index: 0
  arr[1]: 333444
initFunc:
- arrayInit
- - 'myArray'
  - 0
  - 20
  - 30
endFunc:
- arrayTest
- - 'myArray'
  - 0
  - 20
  - 30
expect:
- a.x == 0x10
- rv == 45 && a > 20
- index >= 0
- charArray == "hello"'
- rv == 8  &&  g_char1 == 'a' @@ b d   # rv is written in binary and g_char1 in decimal format

  id: test-4
  desc: |-
    This test demonstrates analyzer and profiler analysis.
  func: [max_int, [8, 456], rv]
  expect:
  - rv == 456
  analyzer:
    runMode: start
    document: max_int.trd
    openMode: w
    trigger: Profiler
    coverage:
      isActive: true
      exportFormat: HTML
      exportFile: testExport.html
      statistics:
      - func: max_int
        code: 96
        sourceLines: 85
        branches: 100
        notTaken: 100
    profiler:
      isActive: true
      exportFormat: XML
      exportFile: profilerExport.xml
      isSaveHistory: true
      codeAreas:
      - name: 'max_int'
        netTime:
          min:
          - 6000
          - 8000
          max:
          - 6000
          - 8000
          total:
          - 6500
          - 8000
        grossTime:
          total:
          - 6000
        hits:
        - 1
        - 1
      dataAreas:
      - name: d
  tests:
  - id: test-5
    imports:
      analyzer:
        inherit: true
    func: ['', [-2, -4]]
    expect:
    - rv == -2
  - id: test-6
    func: ['', [8, 2]]
    expect:
    - rv == 8
    analyzer:
      runMode: start
      document: max_int.trd
      openMode: w
      profiler:
        isActive: true
        isSaveHistory: true
        codeAreas:
        - name: 'max_int'
          netTime:
            min:
            - 4001
            - 8001
            max:
            - 4002
            - 8002
            total:
            - 4003
            - 8003
          hits:
          - 1
          - 4

imports (isys::CTestImports)

Defines inheritance for all other sections. This section is never inherited from base test case.

Syntax:

imports:
  id: 
    inherit: <true | false>
    ids: [<testId>, ...]
  scope: 
    inherit: <true | false>
    ids: [<testId>, ...]
  desc: 
    inherit: <true | false>
    ids: [<testId>, ...]
  tags: 
    inherit: <true | false>
    ids: [<testId>, ...]
  options: 
    inherit: <true | false>
    ids: [<testId>, ...]
  persistVars: 
    inherit: <true | false>
    ids: [<testId>, ...]
  locals: 
    inherit: <true | false>
    ids: [<testId>, ...]
  init: 
    inherit: <true | false>
    ids: [<testId>, ...]
  beginStopCondition: 
    inherit: <true | false>
    ids: [<testId>, ...]
  endStopCondition: 
    inherit: <true | false>
    ids: [<testId>, ...]
  func: 
    inherit: <true | false>
    ids: [<testId>, ...]
  testTimeout: 
    inherit: <true | false>
    ids: [<testId>, ...]
  coreId: 
    inherit: <true | false>
    ids: [<testId>, ...]
  initTargetFunc: 
    inherit: <true | false>
    ids: [<testId>, ...]
  initFunc: 
    inherit: <true | false>
    ids: [<testId>, ...]
  endFunc: 
    inherit: <true | false>
    ids: [<testId>, ...]
  restoreTargetFunc: 
    inherit: <true | false>
    ids: [<testId>, ...]
  stubs: 
    inherit: <true | false>
    ids: [<testId>, ...]
  userStubs: 
    inherit: <true | false>
    ids: [<testId>, ...]
  testPoints: 
    inherit: <true | false>
    ids: [<testId>, ...]
  preCondition: 
    inherit: <true | false>
    ids: [<testId>, ...]
  assert: 
    inherit: <true | false>
    ids: [<testId>, ...]
  stackUsage: 
    inherit: <true | false>
    ids: [<testId>, ...]
  log: 
    inherit: <true | false>
    ids: [<testId>, ...]
  analyzer: 
    inherit: <true | false>
    ids: [<testId>, ...]
  hil: 
    inherit: <true | false>
    ids: [<testId>, ...]
  dryRun: 
    inherit: <true | false>
    ids: [<testId>, ...]
  diagrams: 
    inherit: <true | false>
    ids: [<testId>, ...]
  params: 
    inherit: <true | false>
    ids: [<testId>, ...]

where:

id - defines inheritance for test ID.
scope - defines inheritance for test scope.
desc - defines inheritance for description.
tags - defines inheritance for tags.
options - defines inheritance for options.
persistVars - defines inheritance for persistent variables.
locals - defines inheritance for test local variables.
init - defines inheritance for variable initialization.
beginStopCondition - defines inheritance for begin top condition.
endStopCondition - defines inheritance for end stop condition.
func - defines inheritance for function under test.
testTimeout - defines inheritance for test timeout.
coreId - defines inheritance for coreId.
initTargetFunc - defines inheritance for init target script function.
initFunc - defines inheritance for init script function.
endFunc - defines inheritance for end script function.
restoreTargetFunc - defines inheritance for restore target function.
stubs - defines inheritance for stubs.
userStubs - defines inheritance for user stubs.
testPoints - defines inheritance for test points.
preCondition - defines inheritance for preconditions.
assert - defines inheritance for section assert.
stackUsage - defines inheritance for stack usage.
log - defines inheritance for log section.
analyzer - defines inheritance for analyzer section.
hil - defines inheritance for HIL section.
dryRun - defines inheritance for dry run section.
diagrams - defines inheritance for diagrams section.
params - defines inheritance for function parameters.

id (isys::CTestImportSources)

Defines inheritance for test ID.

Syntax:

id:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

scope (isys::CTestImportSources)

Defines inheritance for test scope.

Syntax:

scope:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

desc (isys::CTestImportSources)

Defines inheritance for description.

Syntax:

desc:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

tags (isys::CTestImportSources)

Defines inheritance for tags.

Syntax:

tags:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

options (isys::CTestImportSources)

Defines inheritance for options.

Syntax:

options:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

persistVars (isys::CTestImportSources)

Defines inheritance for persistent variables.

Syntax:

persistVars:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

locals (isys::CTestImportSources)

Defines inheritance for test local variables.

Syntax:

locals:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

init (isys::CTestImportSources)

Defines inheritance for variable initialization.

Syntax:

init:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

beginStopCondition (isys::CTestImportSources)

Defines inheritance for begin top condition.

Syntax:

beginStopCondition:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

endStopCondition (isys::CTestImportSources)

Defines inheritance for end stop condition.

Syntax:

endStopCondition:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

func (isys::CTestImportSources)

Defines inheritance for function under test.

Syntax:

func:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

testTimeout (isys::CTestImportSources)

Defines inheritance for test timeout.

Syntax:

testTimeout:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

coreId (isys::CTestImportSources)

Defines inheritance for coreId.

Syntax:

coreId:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

initTargetFunc (isys::CTestImportSources)

Defines inheritance for init target script function.

Syntax:

initTargetFunc:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

initFunc (isys::CTestImportSources)

Defines inheritance for init script function.

Syntax:

initFunc:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

endFunc (isys::CTestImportSources)

Defines inheritance for end script function.

Syntax:

endFunc:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

restoreTargetFunc (isys::CTestImportSources)

Defines inheritance for restore target function.

Syntax:

restoreTargetFunc:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

stubs (isys::CTestImportSources)

Defines inheritance for stubs.

Syntax:

stubs:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

userStubs (isys::CTestImportSources)

Defines inheritance for user stubs.

Syntax:

userStubs:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

testPoints (isys::CTestImportSources)

Defines inheritance for test points.

Syntax:

testPoints:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

preCondition (isys::CTestImportSources)

Defines inheritance for preconditions.

Syntax:

preCondition:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

assert (isys::CTestImportSources)

Defines inheritance for section assert.

Syntax:

assert:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

stackUsage (isys::CTestImportSources)

Defines inheritance for stack usage.

Syntax:

stackUsage:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

log (isys::CTestImportSources)

Defines inheritance for log section.

Syntax:

log:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

analyzer (isys::CTestImportSources)

Defines inheritance for analyzer section.

Syntax:

analyzer:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

hil (isys::CTestImportSources)

Defines inheritance for HIL section.

Syntax:

hil:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

dryRun (isys::CTestImportSources)

Defines inheritance for dry run section.

Syntax:

dryRun:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

diagrams (isys::CTestImportSources)

Defines inheritance for diagrams section.

Syntax:

diagrams:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

params (isys::CTestImportSources)

Defines inheritance for function parameters.

Syntax:

params:
  inherit: <true | false>
  ids: [<testId>, ...]

where:

inherit - if true, section is inherited, if false, it is not inherited, if empty it is inherited only if the section is not defined in this test case.
ids - ignored, not impemented yet

persistVars (isys::CTestPersistentVars)

This section manages variables, which have lifetime of more than one test case. If you need variables for one test only, use test local variables.

Syntax:

persistVars:
  decl: {<varName>: <varType>, ...}
  delete: [<varName>, ...]
  isDeleteAll: <true | false>

where:

decl - declarations of persistent variables. They are created before the test starts.
delete - variables from this list are deleted when the test ends.
isDeleteAll - if true, all existing persistent variables are deleted when the test ends.

Example(s):

    persistVars:
      decl:
        per_v: Vehicle

beginStopCondition (isys::CTestStopCondition)

This section defines where the target should stop before test is started.

Syntax:

beginStopCondition:
  stopType: <breakpoint | stop | rtExpression | noRun>
  timeout: <milliseconds>
  rtExpression: <expression>
  conditionCount: <count>
  conditionExpr: <expression>
  bpLocation: 
    resourceType: <function | file | address>
    resourceName: <fileName or functionName>
    srcFileLocation: <localHost | winIDEAHost>
    line: <number>
    isSearch: <true | false>
    linesRange: <number>
    searchContext: <any | code | comment>
    matchType: <plain | regEx | testPointId>
    pattern: <pattern>
    lineOffset: <number>
    numSteps: <number>

where:

stopType - defines how or when to stop the target

breakpoint - target will stop when breskpoint is hit. Breakpoint location is defined by tag bpLocation below.
stop - target will be stopped by emulator when timeout expires, see tag timeout below.
rtExpression - target will be stopped by emulator when real time expression evaluates to true, see tag rtExpression below. Target must support real-time access for this option to work.
noRun - target will not be run - this stop condition is not active.

timeout - timeout in milliseconds:
- if stop type is set to breakpoint, then breakpoint is set after this timeout expires.
- if stop type is set to stop, then target is stopped after this timeout.
- if stop type is set to rtExpression, then expression evaluation starts after this timeout.
rtExpression - real-time expression used when stopType == rtExpression
conditionCount - condition count for breakpoint
conditionExpr - condition expression for breakpoint
bpLocation - breakpoint location

bpLocation (isys::CTestLocation)

Breakpoint location

Syntax:

bpLocation:
  resourceType: <function | file | address>
  resourceName: <fileName or functionName>
  srcFileLocation: <localHost | winIDEAHost>
  line: <number>
  isSearch: <true | false>
  linesRange: <number>
  searchContext: <any | code | comment>
  matchType: <plain | regEx | testPointId>
  pattern: <pattern>
  lineOffset: <number>
  numSteps: <number>

where:

resourceType - resource of location

function - function is used for test point location - line numbers are function relative.
file - file is used for test point location - line numbers are file relative.
address - address is used for test point location - intended for iSYSTEM internal use.

resourceName - file or function name, depending on resourceType above.
srcFileLocation - defines where to read sources from

localHost - sources will be read from local host, where isystem.connect client is running
winIDEAHost - sources will be read from remote host, where winIDEA is running

line - Defines line number where breakpoint is set, or search starts, if search parameters are defined below.
isSearch - if true, line is determined by searching source code as defined below.
linesRange - Defines range of lines to be used when searching for the location line. If empty or set to 0, all lines till the end of file are searched for pattern.
searchContext - defines which parts of the file to use when searching for pattern

any - complete line is searched for pattern.
code - only code is searched for pattern. Single line comment (//) is removed.
comment - only comment is searched (single line comment is recognized only (//)).

matchType - defines how to match the pattern to text.

plain - pattern is used for search literally.
regEx - pattern is interpreted as regular expression.
testPointId - Search pattern is composed of string 'TID: ' and Test Point ID. Tag pattern is ignored.

pattern - Defines pattern for search algorithm. Depending on matching type it can be either regular expression or plain text.
Most often used regular expression tokens:
. - any character
* - character before this one repeats 0 or more times
+ - character before this one repeats 1 or more times
[] - any character inside square brackets.
Examples:
- match exactly one of 'tp1', 'tp2', 'tpA': tp[12A]
- match 'tp' followed by any character: tp.
- match 'tp' followed by any sequence of characters: tp.*
lineOffset - This value is added to the line number defined above or found by search. It can be used, when there is no specific string in the line where we want to define a location. Negative numbers are allowed.
numSteps - Number of execution steps (step over) to execute after test point is hit, before logging and assignments are performed.

endStopCondition (isys::CTestStopCondition)

This section defines where the target should stop to finish the test.

Syntax:

endStopCondition:
  stopType: <breakpoint | stop | rtExpression | noRun>
  timeout: <milliseconds>
  rtExpression: <expression>
  conditionCount: <count>
  conditionExpr: <expression>
  bpLocation: 
    resourceType: <function | file | address>
    resourceName: <fileName or functionName>
    srcFileLocation: <localHost | winIDEAHost>
    line: <number>
    isSearch: <true | false>
    linesRange: <number>
    searchContext: <any | code | comment>
    matchType: <plain | regEx | testPointId>
    pattern: <pattern>
    lineOffset: <number>
    numSteps: <number>

where:

stopType - defines how or when to stop the target

breakpoint - target will stop when breskpoint is hit. Breakpoint location is defined by tag bpLocation below.
stop - target will be stopped by emulator when timeout expires, see tag timeout below.
rtExpression - target will be stopped by emulator when real time expression evaluates to true, see tag rtExpression below. Target must support real-time access for this option to work.
noRun - target will not be run - this stop condition is not active.

timeout - timeout in milliseconds:
- if stop type is set to breakpoint, then breakpoint is set after this timeout expires.
- if stop type is set to stop, then target is stopped after this timeout.
- if stop type is set to rtExpression, then expression evaluation starts after this timeout.
rtExpression - real-time expression used when stopType == rtExpression
conditionCount - condition count for breakpoint
conditionExpr - condition expression for breakpoint
bpLocation - breakpoint location

func (isys::CTestFunction)

This section specifies the function to be tested in unit tests. It can be written as mapping as shown below, but also as list: [, [, ...], ]. Always use mapping form when writing comments to sections.

Syntax:

func:
  func: <functionName>
  params: [<parameter>, ...]
  retVal: <varName>

where:

func - name of function
params - parameters
retVal - name of variable to be used to store function return value. Used only for function under test, ignored for script functions.

Example(s):

    func:
      func: min_int
      params:
      - 4
      - 9
      retVal: rv

    func: [min_int, [4, 9], rv]
    expect: [rv == 4]

initTargetFunc (isys::CTestFunction)

This section specifies which script function should be called to initialize the target before test.

Syntax:

initTargetFunc:
  func: <functionName>
  params: [<parameter>, ...]
  retVal: <varName>

where:

func - name of function
params - parameters
retVal - name of variable to be used to store function return value. Used only for function under test, ignored for script functions.

Example(s):

    func:
      func: min_int
      params:
      - 4
      - 9
      retVal: rv

    func: [min_int, [4, 9], rv]
    expect: [rv == 4]

initFunc (isys::CTestFunction)

This section specifies which script function should be called before the tested function is called. Local test variables are already created and initialized at this time. Trace, profiler, and coverage are also initialized according to specification.
This function may be used for additional target initialization or initialization of complex variables (arrays and structures).

Syntax:

initFunc:
  func: <functionName>
  params: [<parameter>, ...]
  retVal: <varName>

where:

func - name of function
params - parameters
retVal - name of variable to be used to store function return value. Used only for function under test, ignored for script functions.

Example(s):

    func:
      func: min_int
      params:
      - 4
      - 9
      retVal: rv

    func: [min_int, [4, 9], rv]
    expect: [rv == 4]

endFunc (isys::CTestFunction)

This section specifies which script function should be called after the tested function returns. It can be used for complex text verifications, which can not be described by YAML test specfication.
For example, contents of arrays may be verified using this function, or additional data retrieved from trace, coverage or profiler.

Syntax:

endFunc:
  func: <functionName>
  params: [<parameter>, ...]
  retVal: <varName>

where:

func - name of function
params - parameters
retVal - name of variable to be used to store function return value. Used only for function under test, ignored for script functions.

Example(s):

    func:
      func: min_int
      params:
      - 4
      - 9
      retVal: rv

    func: [min_int, [4, 9], rv]
    expect: [rv == 4]

restoreTargetFunc (isys::CTestFunction)

This section specifies which function in the test suite should be called after the test ends. It can be used to restore target state after the test, usually to revert changes done in initTargetFunc.
For example, global variables may be restored.

Syntax:

restoreTargetFunc:
  func: <functionName>
  params: [<parameter>, ...]
  retVal: <varName>

where:

func - name of function
params - parameters
retVal - name of variable to be used to store function return value. Used only for function under test, ignored for script functions.

Example(s):

    func:
      func: min_int
      params:
      - 4
      - 9
      retVal: rv

    func: [min_int, [4, 9], rv]
    expect: [rv == 4]

stubs (isys::CTestStub)

This section defines which functions called by the function under test should be stubbed. This means, that stubbed functions are not executed, while their side effects are simulated. For example, the return value and global variables are set. It is also possible to specify the script extension method to be called, when the stub is hit.

Syntax:

stubs:
- stubbedFunc: <functionName>
  isActive: <true | false>
  isCustomActivation: <true | false>
  params: [<parameter>, ...]
  retValName: <varName>
  scriptFunc: <functionName>
  hitLimits: 
    min: <numHits>
    max: <numHits>
  log: 
    before: [<varName>, ...]
    after: [<varName>, ...]
  assignSteps: 
  - expect: [<expression>, ...]
    assign: {<varName>: <varValue>, ...}
    scriptParams: [<parameter>, ...]
    next: <index>
  - ...
- ...

where:

stubbedFunc - name of the function to be stubbed. Required.
isActive - defines if stub is active or not. This setting enables us to temporarily disable a stub without deleting all data.
isCustomActivation - if set to true, then breakpoint should be set by script. This feature should be used, when there are not enough hardware breakpoints available for all test-points and stubs.
params - this subsection defines names of parameters for stubbed function. This is useful, when pointers or references are passed as parameters and we want to set their values before returning from the stub. Names are assigned to parameters in the same order as specified (the first name to the first parameter, etc.). It is not required to specify names of all parameters - parameters from the end of the list may be ommited, if not used.
retValName - name of the variable to contain return value. If not needed, this item may be ommited.
Because of compiler optimizations, it is usually better to first assign values to parameters, and only then to assign a return value.
scriptFunc - name of the script extension function, which should be called when the stub is hit.
hitLimits - defines limits for number of hits for this stub. If recorded number of hits is outside these limits, test fails.
log - this section contains variables to be logged before and after stub execution.
assignSteps - this section contains evaluation and assignment steps.

Example(s):

    func: [funcForIntStubTest, [], retVal]
    stubs:
    - func: [stubbedFuncInt, stubRV]
      assignSteps:
      - assign:
          stubRV: 654
        scriptParams: [3, 4]
      - assign:
          stubRV: 655
        scriptParams: [4, 5]
        next: 0     # continue with the first step
    expect:
    - retVal == 700

hitLimits (isys::CTestMinMax)

Defines limits for number of hits for this stub. If recorded number of hits is outside these limits, test fails.

Syntax:

hitLimits:
  min: <numHits>
  max: <numHits>

where:

min - defines minimum number of hits.
max - defines maximum number of hits.

log (isys::CTestLog)

This section contains variables to be logged before and after stub execution.

Syntax:

log:
  before: [<varName>, ...]
  after: [<varName>, ...]

where:

before - variables to log before the parent is executed
after - variables to log after the parent is executed

assignSteps (isys::CTestEvalAssignStep)

This section contains evaluation and assignment steps.

Syntax:

assignSteps:
- expect: [<expression>, ...]
  assign: {<varName>: <varValue>, ...}
  scriptParams: [<parameter>, ...]
  next: <index>
- ...

where:

expect - expressions which must evaluate to true, otherwise test fails.
assign - map of variables and values to be assigned to these variables before the stub returns.
scriptParams - list of parameters for script extension function, which is called when the stub is hit.
next - index of the next step to execute. If empty, next step is assumed, or the last step if there are no more steps defined.

userStubs (isys::CTestUserStub)

This section defines which functions called by the function under test should be stubbed. This means, that stubbed functions are not executed. Instead we can define immediate return (for void functions) or replacement function implemented on target.

Syntax:

userStubs:
- func: <functionName>
  isActive: <true | false>
  replacementFunc: <functionName>
- ...

where:

func - name of the function to be stubbed. Required.
isActive - defines if stub is active or not. This setting enables us to temporarily disable a stub without deleting all data.
replacementFunc - name of the target function to be called instead of stubbed function. If this tag is not present, skip stub is used - return instruction is put at the start of stubbed function. Skip stubs are not recommended for non-void functions, because return value and output parameters are not set.

Example(s):

  func: [funcForIntStubTest, [], rv]
  userStubs:
  - func: stubbedFuncInt
    isActive: true
    replacementFunc: repl_stubbedFuncInt
  expect:
  - rv == 234

testPoints (isys::CTestPoint)

This section defines arbitrary points in source code, where target state (variable values, registers, ...) can be logged, changed or verified.

Syntax:

testPoints:
- tpId: <>
  isActive: <true | false>
  isCustomActivation: <true | false>
  conditionCount: <count>
  conditionExpr: <expression>
  scriptFunc: <functonName>
  location: 
    resourceType: <function | file | address>
    resourceName: <fileName or functionName>
    srcFileLocation: <localHost | winIDEAHost>
    line: <number>
    isSearch: <true | false>
    linesRange: <number>
    searchContext: <any | code | comment>
    matchType: <plain | regEx | testPointId>
    pattern: <pattern>
    lineOffset: <number>
    numSteps: <number>
  log: 
    before: [<varName>, ...]
    after: [<varName>, ...]
  hitLimits: 
    min: <numHits>
    max: <numHits>
  steps: 
  - expect: [<expression>, ...]
    assign: {<varName>: <varValue>, ...}
    scriptParams: [<parameter>, ...]
    next: <index>
  - ...
- ...

where:

tpId - unique ID for test point.
isActive - defines if test point is active or not. This setting enables us to temporarily disable test point without deleting all data.
isCustomActivation - if set to true, then breakpoint should be set by script. This feature should be used, when there are not enough hardware breakpoints available for all test-points and stubs.
conditionCount - condition count for breakpoint used for test point
conditionExpr - condition expression for breakpoint used for test point
scriptFunc - script function to call when test point is hit.
location - location in source code of test point.
log - defines which variables are logged before and after assignments are executed.
hitLimits - defines limits for number of hits for this test point. If recorded number of hits is outside these limits, test fails.
steps - this section contains evaluation and assignment steps.

Example(s):

  testPoints:
  - tpId: tp_id_4
    location:
      resourceName: testPointTest
      line: 0
      isSearch: true
    log:
      before:
      - p1
      - x
      after:
      - p1
    steps:
    - expect:
      - p1 == 11
      assign:
        g_char1: 12
  - tpId: myComplexTestPoint
    scriptFunc: stubFunc3
    location:
      resourceName: testPointTest
      isSearch: true
      searchContext: any
      matchType: plain
      pattern: myComplexTestPoint
    log:
      before:
      - p1
      - x
      after:
      - x
    steps:
    - expect:
      - p1==11
      scriptParams:
      - 45

location (isys::CTestLocation)

Location in source code of test point.

Syntax:

location:
  resourceType: <function | file | address>
  resourceName: <fileName or functionName>
  srcFileLocation: <localHost | winIDEAHost>
  line: <number>
  isSearch: <true | false>
  linesRange: <number>
  searchContext: <any | code | comment>
  matchType: <plain | regEx | testPointId>
  pattern: <pattern>
  lineOffset: <number>
  numSteps: <number>

where:

resourceType - resource of location

function - function is used for test point location - line numbers are function relative.
file - file is used for test point location - line numbers are file relative.
address - address is used for test point location - intended for iSYSTEM internal use.

resourceName - file or function name, depending on resourceType above.
srcFileLocation - defines where to read sources from

localHost - sources will be read from local host, where isystem.connect client is running
winIDEAHost - sources will be read from remote host, where winIDEA is running

line - Defines line number where breakpoint is set, or search starts, if search parameters are defined below.
isSearch - if true, line is determined by searching source code as defined below.
linesRange - Defines range of lines to be used when searching for the location line. If empty or set to 0, all lines till the end of file are searched for pattern.
searchContext - defines which parts of the file to use when searching for pattern

any - complete line is searched for pattern.
code - only code is searched for pattern. Single line comment (//) is removed.
comment - only comment is searched (single line comment is recognized only (//)).

matchType - defines how to match the pattern to text.

plain - pattern is used for search literally.
regEx - pattern is interpreted as regular expression.
testPointId - Search pattern is composed of string 'TID: ' and Test Point ID. Tag pattern is ignored.

pattern - Defines pattern for search algorithm. Depending on matching type it can be either regular expression or plain text.
Most often used regular expression tokens:
. - any character
* - character before this one repeats 0 or more times
+ - character before this one repeats 1 or more times
[] - any character inside square brackets.
Examples:
- match exactly one of 'tp1', 'tp2', 'tpA': tp[12A]
- match 'tp' followed by any character: tp.
- match 'tp' followed by any sequence of characters: tp.*
lineOffset - This value is added to the line number defined above or found by search. It can be used, when there is no specific string in the line where we want to define a location. Negative numbers are allowed.
numSteps - Number of execution steps (step over) to execute after test point is hit, before logging and assignments are performed.

log (isys::CTestLog)

Defines which variables are logged before and after assignments are executed.

Syntax:

log:
  before: [<varName>, ...]
  after: [<varName>, ...]

where:

before - variables to log before the parent is executed
after - variables to log after the parent is executed

hitLimits (isys::CTestMinMax)

Defines limits for number of hits for this test point. If recorded number of hits is outside these limits, test fails.

Syntax:

hitLimits:
  min: <numHits>
  max: <numHits>

where:

min - defines minimum number of hits.
max - defines maximum number of hits.

steps (isys::CTestEvalAssignStep)

This section contains evaluation and assignment steps.

Syntax:

steps:
- expect: [<expression>, ...]
  assign: {<varName>: <varValue>, ...}
  scriptParams: [<parameter>, ...]
  next: <index>
- ...

where:

expect - expressions which must evaluate to true, otherwise test fails.
assign - map of variables and values to be assigned to these variables before the stub returns.
scriptParams - list of parameters for script extension function, which is called when the stub is hit.
next - index of the next step to execute. If empty, next step is assumed, or the last step if there are no more steps defined.

preCondition (isys::CTestAssert)

This section specifies conditions to be fulfilled before the test starts. Conditions are specified as expressions, which must evaluate to true.

Syntax:

preCondition:
  isExpectException: <true | false>
  expressions: [<C expression>, ...]

where:

isExpectException - if true, target exception is expected test result. In such case special variable isystem_test_exception contains thrown exception and can be used in expressions under assert tag. This item is ignored if specified in preCondition tag.
expressions - This section specifies expressions, which should evaluate to true, after the tested function returns. If any expression evaluates to false, the test fails.
Floating point values are compared for equality with precision defined in evaluator configuration section, see vagueFloatPrecision.
When the expression evaluates to false, variables in the expression are evaluated and their values written in error message. Integers are written in the format selected in winIDEA Watch window - either hex or dec. To write values in custom format, you can add format specifier to the expression. It must be separated from expression with string @@. The following specifiers are currently supported:
- b - binary format, for example: 00000001
- d - decimal format, for example: 1
- h - hexadecimal format, for example: 0x01
Format specifiers must be separated by spaces. Each specifier is applied to variable as it appears in the expression from left to right. If there are more specifiers than variables, excessive specifiers are ignored. If there are less specifiers than variables, values of remaining variables are displayed according to setting in winIDEA Watch window.
We can test the following data:
- function return value, for example: rv == 34
- variables declared in the variables section, for example: *ptr == 42
- target global variables
- target registers by using prefix '@', for example: @R3 == 42
- IO module inputs by using backquotes as a prefix, for example: `DigitalIn.DIN0 == 1

assert (isys::CTestAssert)

This section specifies expected outcome of test regarding target exceptions and values of variables, registers, ...

Syntax:

assert:
  isExpectException: <true | false>
  expressions: [<C expression>, ...]

where:

isExpectException - if true, target exception is expected test result. In such case special variable isystem_test_exception contains thrown exception and can be used in expressions under assert tag. This item is ignored if specified in preCondition tag.
expressions - This section specifies expressions, which should evaluate to true, after the tested function returns. If any expression evaluates to false, the test fails.
Floating point values are compared for equality with precision defined in evaluator configuration section, see vagueFloatPrecision.
When the expression evaluates to false, variables in the expression are evaluated and their values written in error message. Integers are written in the format selected in winIDEA Watch window - either hex or dec. To write values in custom format, you can add format specifier to the expression. It must be separated from expression with string @@. The following specifiers are currently supported:
- b - binary format, for example: 00000001
- d - decimal format, for example: 1
- h - hexadecimal format, for example: 0x01
Format specifiers must be separated by spaces. Each specifier is applied to variable as it appears in the expression from left to right. If there are more specifiers than variables, excessive specifiers are ignored. If there are less specifiers than variables, values of remaining variables are displayed according to setting in winIDEA Watch window.
We can test the following data:
- function return value, for example: rv == 34
- variables declared in the variables section, for example: *ptr == 42
- target global variables
- target registers by using prefix '@', for example: @R3 == 42
- IO module inputs by using backquotes as a prefix, for example: `DigitalIn.DIN0 == 1

stackUsage (isys::CTestStackUsage)

This section defines the limits for stack used by current test case.

Syntax:

stackUsage:
  minLimit: <numBytes>
  maxLimit: <numBytes>

where:

minLimit - minimum amount of stack to be used during test.
maxLimit - maximum amount of stack to be used during test.

log (isys::CTestLog)

This section defines setting for logging of values before and after test.

Syntax:

log:
  before: [<varName>, ...]
  after: [<varName>, ...]

where:

before - variables to log before the parent is executed
after - variables to log after the parent is executed

analyzer (isys::CTestAnalyzer)

This section defines setting for coverage, profiler, and trace.

Syntax:

analyzer:
  runMode: <off | start>
  document: <fileName>
  openMode: <u | w | a>
  isSlowRun: <true | false>
  trigger: <triggerName>
  isPredefTrigger: <true | false>
  isSaveAfterTest: <true | false>
  isCloseAfterTest: <true | false>
  trace: 
    isActive: <true | false>
    exportFormat: <Text | CSV | Binary | XML>
    exportFile: <fileName>
  coverage: 
    isActive: <true | false>
    isMeasureAllFunctions: <true | false>
    isIgnoreNonReachableCode: <true | false>
    mergeScope: <none | siblingsOnly | siblingsAndParent | all>
    mergeFilter: 
      filterId: <>
      type: <builtIn | script>
      coreId: <>
      partitions: [<partition>, ...]
      modules: [<>, ...]
      includedIds: [<testId>, ...]
      excludedIds: [<testId>, ...]
      includedFunctions: [<functionName>, ...]
      excludedFunctions: [<functionName>, ...]
      mustHaveAllTags: [<tag>, ...]
      mustHaveOneOfTags: [<tag>, ...]
      mustNotHaveAllTags: [<tag>, ...]
      mustNotHaveOneOfTags: [<tag>, ...]
      isOr1: <true | false>
      isOr2: <true | false>
      isOr3: <true | false>
      scriptFunction: <scriptFunctionName>
      scriptFunctionParams: [<scriptFunctionParam>, ...]
    exportFormat: <HTML | Text | CSV | XML | Review (HTML) | Review (Text)>
    formatVariant: <variantName>
    exportFile: <fileName>
    isAssemblerInfo: <true | false>
    isLaunchViewer: <true | false>
    isExportModuleLines: <true | false>
    isExportSources: <true | false>
    isExportFunctionLines: <true | false>
    isExportAsm: <true | false>
    isExportRanges: <true | false>
    exportFunctionsFilter: <functionName>
    exportModulesFilter: <moduleName>
    statistics: 
    - func: <functionName>
      code: <percentage>
      sourceLines: <percentage>
      branches: <percentage>
      taken: <percentage>
      notTaken: <percentage>
      both: <percentage>
      execCount: <>
    - ...
  profiler: 
    isActive: <true | false>
    isMeasureAllFunctions: <true | false>
    exportFormat: <Text | XML | CSV | Text1 | XMLBinaryTimeline | BTF | MDF>
    exportFile: <>
    isExportActiveOnly: <true | false>
    isProfileAUX: <true | false>
    isSaveHistory: <true | false>
    codeAreas: 
    - name: <funcName or varName>
      value: <stateValue>
      netTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      grossTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      callTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      periodTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      outsideTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      hits: [<number>, ...]
    - ...
    dataAreas: 
    - name: <funcName or varName>
      value: <stateValue>
      netTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      grossTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      callTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      periodTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      outsideTime: 
        min: [<lowerBound>, <upperBound>]
        minStart: [<lowerBound>, <upperBound>]
        minEnd: [<lowerBound>, <upperBound>]
        max: [<lowerBound>, <upperBound>]
        maxStart: [<lowerBound>, <upperBound>]
        maxEnd: [<lowerBound>, <upperBound>]
        total: [<lowerBound>, <upperBound>]
        average: [<lowerBound>, <upperBound>]
      hits: [<number>, ...]
    - ...

where:

runMode - analyzer run mode, off (default) or start. Off mode can be used to temporarily disable trace without removing complete trace specification from test case. If not specified, off is the default value.

off - analyzer is not started
start - analyzer is started

document - name of the document (file) to open in winIDEA. Required. It is highly recommended to use the extension *.trd for file name.
openMode - document open mode.

u - opens existing file for update.
w - (default) opens existing file and deletes contents or creates new file.
a - opens existing file and keeps contents, or creates new file. Currently contents is appended only for coverage.

isSlowRun - if true, then slow run is used for analyzer. This way analyzer can be run on targets without trace capabilities.
trigger - name of the trigger in trace document. Trigger should be configured in winIDEA.
isPredefTrigger - if true, analyzer trigger is not configured by itest, but existing trigger in analyzer file is used.
isSaveAfterTest - if true, the document is saved after test. false by default.
isCloseAfterTest - if true, the document is closed after test. false by default.
trace - trace configuration.
coverage - coverage configuration with statistics criteria.
profiler - profiler configuration with statistics criteria.

Example(s):

  analyzer:
    runMode: start
    document: cumulative.trd
    openMode: w
    isSaveAfterTest: true
    isCloseAfterTest: false
    coverage:
      isActive: true
      statistics:
      - func: complexFunction
        code: 50

trace (isys::CTestAnalyzerTrace)

Trace configuration.

Syntax:

trace:
  isActive: <true | false>
  exportFormat: <Text | CSV | Binary | XML>
  exportFile: <fileName>

where:

isActive - if true, trace is recorded.
exportFormat - name of the export format.

Text - specifies text export format.
CSV - specifies CSV export format.
Binary - specifies binary export format.
XML - specifies XML export format.

exportFile - if this item is defined, trace results are exported to file with this name in format specified by exportFormat.

coverage (isys::CTestAnalyzerCoverage)

Coverage configuration with statistics criteria.

Syntax:

coverage:
  isActive: <true | false>
  isMeasureAllFunctions: <true | false>
  isIgnoreNonReachableCode: <true | false>
  mergeScope: <none | siblingsOnly | siblingsAndParent | all>
  mergeFilter: 
    filterId: <>
    type: <builtIn | script>
    coreId: <>
    partitions: [<partition>, ...]
    modules: [<>, ...]
    includedIds: [<testId>, ...]
    excludedIds: [<testId>, ...]
    includedFunctions: [<functionName>, ...]
    excludedFunctions: [<functionName>, ...]
    mustHaveAllTags: [<tag>, ...]
    mustHaveOneOfTags: [<tag>, ...]
    mustNotHaveAllTags: [<tag>, ...]
    mustNotHaveOneOfTags: [<tag>, ...]
    isOr1: <true | false>
    isOr2: <true | false>
    isOr3: <true | false>
    scriptFunction: <scriptFunctionName>
    scriptFunctionParams: [<scriptFunctionParam>, ...]
  exportFormat: <HTML | Text | CSV | XML | Review (HTML) | Review (Text)>
  formatVariant: <variantName>
  exportFile: <fileName>
  isAssemblerInfo: <true | false>
  isLaunchViewer: <true | false>
  isExportModuleLines: <true | false>
  isExportSources: <true | false>
  isExportFunctionLines: <true | false>
  isExportAsm: <true | false>
  isExportRanges: <true | false>
  exportFunctionsFilter: <functionName>
  exportModulesFilter: <moduleName>
  statistics: 
  - func: <functionName>
    code: <percentage>
    sourceLines: <percentage>
    branches: <percentage>
    taken: <percentage>
    notTaken: <percentage>
    both: <percentage>
    execCount: <>
  - ...

where:

isActive - if true, coverage is recorded
isMeasureAllFunctions - if true, coverage of all function is recorded, not only of those added in statistics section.
isIgnoreNonReachableCode - This setting is passed to winIDEA analyzer configuration.
mergeScope - this section define merging scope.

none - no merging is performed.
siblingsOnly - only siblings of this test case, which have already been executed, are used as filter input.
siblingsAndParent - only siblings and parent of this test case, which have already been executed, are used as filter input.
all - all test cases which have been executed up to this point are used as filter input

mergeFilter - this section define merging filter. If empty, no tests are excluded.
exportFormat - name of the export format.

HTML - specifies HTML export format.
Text - specifies text export format.
CSV - specifies CSV export format.
XML - specifies XML export format.
Review (HTML) - deprecated.
Review (Text) - deprecated.

formatVariant - variant of the export format, usually empty.
exportFile - if this item is defined, coverage results are exported to file with this name in format specified by exportFormat.
isAssemblerInfo - if true, information about assembly level coverage will be provided.
isLaunchViewer - default system viewer for exported files will be launched after export.
isExportModuleLines - if true, lines coverage for modules will be exported.
isExportSources - source line coverage will be exported. It contains the sameinformation with markers as shown in winDIDEA source file.
isExportFunctionLines - if true, lines coverage for modules will be exported.
isExportAsm - coverage of assembler level instructions will be exported.
isExportRanges - coverage of ranges without source info will be exported.
exportFunctionsFilter - filter for functions to be exported.
exportModulesFilter - filter for modules to be exported.
statistics - this section contains coverage statistics criteria.

Example(s):

    coverage:
      isActive: true
      exportFormat: HTML
      exportFile: testExport.html
      statistics:
      - func: max_int
        code: 96
        sourceLines: 85
        branches: 100
        notTaken: 100

profiler (isys::CTestAnalyzerProfiler)

Profiler configuration with statistics criteria.

Syntax:

profiler:
  isActive: <true | false>
  isMeasureAllFunctions: <true | false>
  exportFormat: <Text | XML | CSV | Text1 | XMLBinaryTimeline | BTF | MDF>
  exportFile: <>
  isExportActiveOnly: <true | false>
  isProfileAUX: <true | false>
  isSaveHistory: <true | false>
  codeAreas: 
  - name: <funcName or varName>
    value: <stateValue>
    netTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    grossTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    callTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    periodTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    outsideTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    hits: [<number>, ...]
  - ...
  dataAreas: 
  - name: <funcName or varName>
    value: <stateValue>
    netTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    grossTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    callTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    periodTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    outsideTime: 
      min: [<lowerBound>, <upperBound>]
      minStart: [<lowerBound>, <upperBound>]
      minEnd: [<lowerBound>, <upperBound>]
      max: [<lowerBound>, <upperBound>]
      maxStart: [<lowerBound>, <upperBound>]
      maxEnd: [<lowerBound>, <upperBound>]
      total: [<lowerBound>, <upperBound>]
      average: [<lowerBound>, <upperBound>]
    hits: [<number>, ...]
  - ...

where:

isActive - if true, profiling data is recorded
isMeasureAllFunctions - if true, profiling data of all function is recorded, not only of those added in code areas.
exportFormat - name of the export format.

Text - specifies text export format.
XML - specifies XML export format.
CSV - specifies CSV export format.
Text1 - specifies Text1 export format.
XMLBinaryTimeline - specifies XML export format for statistics, binary file for timeline.
BTF - specifies BTF export format.
MDF - specifies MDF export format.

exportFile - if this item is defined, profiler results are exported to file with this name in format specified by exportFormat.
isExportActiveOnly - only areas with recoded activity (functions executed and data modified) will be exported.
isProfileAUX - if true, AUX signals will be recorded.
isSaveHistory - if true, profiler timeline results will be saved after test.
codeAreas - profiler statistics criteria for functions.
dataAreas - profiler statistics criteria for state variables.

Example(s):

  analyzer:
    profiler:
      isActive: true
      exportFormat: XML
      exportFile: profilerExport.xml
      isSaveHistory: true
      codeAreas:
      - name: 'max_int'
        netTime:
          min:
          - 6000
          - 8000
          max:
          - 6000
          - 8000
          total:
          - 6500
          - 8000
        grossTime:
          total:
          - 6000
        hits:
        - 1
        - 1

codeAreas (isys::CTestProfilerStatistics)

Profiler statistics criteria for functions.

Syntax:

codeAreas:
- name: <funcName or varName>
  value: <stateValue>
  netTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  grossTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  callTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  periodTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  outsideTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  hits: [<number>, ...]
- ...

where:

name - function name for code area, variable name for data area. Required.
value - should be empty for code area, state value for data area
netTime - time spent for code inside function body, without sub-functions called from this function.
grossTime - time spent for code inside function body, AND sub-functions called from this function.
callTime - gross time plus time spent in other contexts (tasks, interrupts) between entry/exit of a function.
periodTime - time between function invocation. Total time is not defined for this type of time.
outsideTime - time spent outside a state - when the state is inactive.
hits - time spent outside a state - when the state is inactive.

netTime (isys::CTestProfilerTime)

Time spent for code inside function body, without sub-functions called from this function.

Syntax:

netTime:
  min: [<lowerBound>, <upperBound>]
  minStart: [<lowerBound>, <upperBound>]
  minEnd: [<lowerBound>, <upperBound>]
  max: [<lowerBound>, <upperBound>]
  maxStart: [<lowerBound>, <upperBound>]
  maxEnd: [<lowerBound>, <upperBound>]
  total: [<lowerBound>, <upperBound>]
  average: [<lowerBound>, <upperBound>]

where:

min - minimum expected time for function execution or state duration
minStart - expected start of shortest function execution or state duration
minEnd - expected end of fastest function execution or shortest state duration
max - maximum expected time for function execution or state duration
maxStart - expected start of slowest function execution or longest state duration
maxEnd - expected end of slowest function execution or longest state duration
total - average expected time for function execution or state duration
average - total expected time for function execution or state duration

grossTime (isys::CTestProfilerTime)

Time spent for code inside function body, AND sub-functions called from this function.

Syntax:

grossTime:
  min: [<lowerBound>, <upperBound>]
  minStart: [<lowerBound>, <upperBound>]
  minEnd: [<lowerBound>, <upperBound>]
  max: [<lowerBound>, <upperBound>]
  maxStart: [<lowerBound>, <upperBound>]
  maxEnd: [<lowerBound>, <upperBound>]
  total: [<lowerBound>, <upperBound>]
  average: [<lowerBound>, <upperBound>]

where:

min - minimum expected time for function execution or state duration
minStart - expected start of shortest function execution or state duration
minEnd - expected end of fastest function execution or shortest state duration
max - maximum expected time for function execution or state duration
maxStart - expected start of slowest function execution or longest state duration
maxEnd - expected end of slowest function execution or longest state duration
total - average expected time for function execution or state duration
average - total expected time for function execution or state duration

callTime (isys::CTestProfilerTime)

Gross time plus time spent in other contexts (tasks, interrupts) between entry/exit of a function.

Syntax:

callTime:
  min: [<lowerBound>, <upperBound>]
  minStart: [<lowerBound>, <upperBound>]
  minEnd: [<lowerBound>, <upperBound>]
  max: [<lowerBound>, <upperBound>]
  maxStart: [<lowerBound>, <upperBound>]
  maxEnd: [<lowerBound>, <upperBound>]
  total: [<lowerBound>, <upperBound>]
  average: [<lowerBound>, <upperBound>]

where:

min - minimum expected time for function execution or state duration
minStart - expected start of shortest function execution or state duration
minEnd - expected end of fastest function execution or shortest state duration
max - maximum expected time for function execution or state duration
maxStart - expected start of slowest function execution or longest state duration
maxEnd - expected end of slowest function execution or longest state duration
total - average expected time for function execution or state duration
average - total expected time for function execution or state duration

periodTime (isys::CTestProfilerTime)

Time between function invocation. Total time is not defined for this type of time.

Syntax:

periodTime:
  min: [<lowerBound>, <upperBound>]
  minStart: [<lowerBound>, <upperBound>]
  minEnd: [<lowerBound>, <upperBound>]
  max: [<lowerBound>, <upperBound>]
  maxStart: [<lowerBound>, <upperBound>]
  maxEnd: [<lowerBound>, <upperBound>]
  total: [<lowerBound>, <upperBound>]
  average: [<lowerBound>, <upperBound>]

where:

min - minimum expected time for function execution or state duration
minStart - expected start of shortest function execution or state duration
minEnd - expected end of fastest function execution or shortest state duration
max - maximum expected time for function execution or state duration
maxStart - expected start of slowest function execution or longest state duration
maxEnd - expected end of slowest function execution or longest state duration
total - average expected time for function execution or state duration
average - total expected time for function execution or state duration

outsideTime (isys::CTestProfilerTime)

Time spent outside a state - when the state is inactive.

Syntax:

outsideTime:
  min: [<lowerBound>, <upperBound>]
  minStart: [<lowerBound>, <upperBound>]
  minEnd: [<lowerBound>, <upperBound>]
  max: [<lowerBound>, <upperBound>]
  maxStart: [<lowerBound>, <upperBound>]
  maxEnd: [<lowerBound>, <upperBound>]
  total: [<lowerBound>, <upperBound>]
  average: [<lowerBound>, <upperBound>]

where:

min - minimum expected time for function execution or state duration
minStart - expected start of shortest function execution or state duration
minEnd - expected end of fastest function execution or shortest state duration
max - maximum expected time for function execution or state duration
maxStart - expected start of slowest function execution or longest state duration
maxEnd - expected end of slowest function execution or longest state duration
total - average expected time for function execution or state duration
average - total expected time for function execution or state duration

dataAreas (isys::CTestProfilerStatistics)

Profiler statistics criteria for state variables.

Syntax:

dataAreas:
- name: <funcName or varName>
  value: <stateValue>
  netTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  grossTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  callTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  periodTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  outsideTime: 
    min: [<lowerBound>, <upperBound>]
    minStart: [<lowerBound>, <upperBound>]
    minEnd: [<lowerBound>, <upperBound>]
    max: [<lowerBound>, <upperBound>]
    maxStart: [<lowerBound>, <upperBound>]
    maxEnd: [<lowerBound>, <upperBound>]
    total: [<lowerBound>, <upperBound>]
    average: [<lowerBound>, <upperBound>]
  hits: [<number>, ...]
- ...

where:

name - function name for code area, variable name for data area. Required.
value - should be empty for code area, state value for data area
netTime - time spent for code inside function body, without sub-functions called from this function.
grossTime - time spent for code inside function body, AND sub-functions called from this function.
callTime - gross time plus time spent in other contexts (tasks, interrupts) between entry/exit of a function.
periodTime - time between function invocation. Total time is not defined for this type of time.
outsideTime - time spent outside a state - when the state is inactive.
hits - time spent outside a state - when the state is inactive.

hil (isys::CTestHIL)

This section contains HIL configuration to be applied before test starts.

Syntax:

hil:
  params: {<hilParamName>: <hilParamValue>, ...}

where:

params - Consult your HIL manual for available parameters and values.

Example(s):

hil:
  params:
    DigitalOut.DOUT0: HIGH

dryRun (isys::CTestDryRun)

This section contains assignments to be copied to section 'init' during Dry Run.

Syntax:

dryRun:
  assign: {<hostVarName>: <expression>, ...}
  isUpdateCoverage: <true | false>
  isUpdateProfiler: <true | false>
  profilerMultiplier: <>
  profilerOffset: <>

where:

assign - Contains assignments to be done after test run. Expressions are evaluated, then assignment is copied to section 'init'
isUpdateCoverage - if true, coverage statistics is also updated during dry run. Only items already defined are updated.
isUpdateProfiler - if true, profiler statistics is also updated during dry run. Only items already defined are updated.
profilerMultiplier - used during updating of profiler statistics: upper_value = measured_value * (1 + multiplier) + offset.
profilerOffset - used during updating of profiler statistics: upper_value = measured_value * (1 + multiplier) + offset.

diagrams (isys::CTestDiagrams)

This section contains specification for test output diagrams.

Syntax:

diagrams:
  isActive: <true | false>
  diagrams: 
  - isActive: <true | false>
    diagramType: <flowChart | sequenceDiagram | callGraph | staticCallGraph | flameGraph | custom | customAsync>
    script: <scriptName.py>
    params: [<arg1>, ...]
    outFile: <fileName>
    isAddToReport: <true | false>
    viewer: <multiPage | singlePage | externalApp | none>
    dataFormat: <byExtension | bitmap | SVG>
    externalViewer: <pathToApp>
  - ...

where:

isActive - if true, diagrams are processed during test run (see also isActive flag for each diagram).
diagrams - Contains specifications of diagrams.

diagrams (isys::CTestDiagramConfig)

Contains specifications of diagrams.

Syntax:

diagrams:
- isActive: <true | false>
  diagramType: <flowChart | sequenceDiagram | callGraph | staticCallGraph | flameGraph | custom | customAsync>
  script: <scriptName.py>
  params: [<arg1>, ...]
  outFile: <fileName>
  isAddToReport: <true | false>
  viewer: <multiPage | singlePage | externalApp | none>
  dataFormat: <byExtension | bitmap | SVG>
  externalViewer: <pathToApp>
- ...

where:

isActive - if true, and isActive flag of parent section is true, this diagram is created during test run.
diagramType - contains one of built-in diagram types or defines a custom diagram type.

flowChart - built-in flow chart based on static analysis of object code is drawn.
sequenceDiagram - built-in sequence diagram based on analyzer recording is drawn. Use testIDEA to properly configure analyzer.
callGraph - built-in call graph based on analyzer recording is drawn. Use testIDEA to properly configure analyzer.
staticCallGraph - built-in call graph based on static object code analysis.
flameGraph - built-in flame graph based on dynamic stack trace analysis.
custom - custom specified script is called to create a diagram.
customAsync - custom specified script is called asynchronously to create a diagram. These diagrams can not be included in reports.

script - for custom diagrams specifies name of Python script to be executed to draw a diagram. It is ignored for built-in diagrams.
params - specifies script arguments, if they are required
outFile - name of output file. It is mandatory, and may contain host variables ${_testID}, ${_funcUnderTest}, and ${_diagramType}. If file name is relative (recommended), diagrams are saved relative to test report directory.
isAddToReport - if true, the link to diagram file is included in test report, when saved. Diagrams of type customAsync can not be added to test report.
viewer - specifies where to show the diagram

multiPage - testIDEA opens diagram in multipage window.
singlePage - testIDEA opens diagram in single-page window.
externalApp - testIDEA opens diagram in external application.
none - testIDEA opens diagram only in section Diagrams.

dataFormat - defines output file format. Bitmap file formats (png is recommended) and vector format (svg is supported) can be used. The recommended value for this column is byExtension and specified extension png or svg in output file.

byExtension - display format is determined on extension: svg, csv, txt, png, jpg, jpeg, bmp
bitmap - one of bitmap formats (jpg, bmp, ...)
SVG - SVG format

externalViewer - path to external application to be used as a diagram viewer