Vector Test Unit for Visual Studio Code

This extension supports you in creating and editing Vector test units (*.vtestunit.yaml).

It interacts with the CAPL, Python, and C# extensions and provides them with type libraries which are necessary to write test implementations.

It provides editing support for test unit configuration files with file endings vtestunit.yaml and vtesttree.yaml. This includes syntax highlighting, code completion, and validation.

Depending on your use case it can also assist you in building and running the test unit.

Prerequisites

The Vector Test Unit extension requires a Vector toolset to be installed. The Vector toolset comes with any CANoe or CANoe Server Edition. It is also part of the freely available Vector Test Unit Runner. Note, that the DevOps workflow is only available with the Server Editions of CANoe and Vector Test Unit Runner as of toolset version 17. The CANoe workflow is only available with the Desktop Editions of CANoe as of toolset version 18.

The currently selected toolset is shown in the status bar. By default, the latest installed version is used. To select a specific version, use the command Vector Test Unit: Select Vector toolset.

The Vector Simulation and Test Environment extension extension is installed automatically as a dependency. It provides your test unit with the environment from a venvironment.yaml or venvironment-basic.yaml description file.

The YAML extension is required for editing vtestunit.yaml and vtesttree.yaml files. It will be installed automatically as a dependency, too.

For editing the actual test implementations, please install the respective programming language extensions CAPL, Python, and C#.

Usage

This extension supports two different workflows. The DevOps workflow is tailored towards the Server Editions of CANoe and Vector Test Unit Runner. The CANoe workflow is for editing vtestunit.yaml-based test units in CANoe editions with a GUI.

Editing test implementations

With this extension all CAPL test files referenced in the test unit description file of the active test unit and all included files will automatically have the test-specific CAPL features enabled.

For editing tests written in C# or Python this extension will enable you to ...

• use built-in symbols, functions and namespaces from the Vector toolset
• use symbols, functions and namespaces from CAPL libraries (check the help of your Vector toolset to see which features are supported in which language)

In case of C# tests the extension additionally enables you to use the .NET assemblies referenced in the test unit description file. In case of Python the packages referenced in the test unit description file should be resolved by default by the Pylance extension.

The C# and Python language support is updated at startup and when changing the active test unit. If you want to update it manually, e.g. when you have just written a CAPL function that you now want to use in a C# or Python test file you can do so using the commands Vector Test Unit: Generate .NET type libraries or Vector Test Unit: Generate Python type libraries respectively.

DevOps workflow

The Vector Test Unit extension discovers all test units in the current workspace by their description files *.vtestunit.yaml. If there is more than one test unit in the workspace you have to choose one as your active test unit using the command Vector Test Unit: Select test unit. The name of the currently active test unit is shown in the status bar.

Test unit description file support

The extension provides editing support for the configuration files vtestunit.yaml and vtesttree.yaml. This includes syntax highlighting, code completion, and validation. The editing support is Vector toolset aware which means that the support will adapt to the file versions available in your Vector toolset.

Building a test unit

Before a test unit can be executed it must be built. The extension provides a build task that can be executed using the commands Vector Test Unit: Build test unit and Tasks: Run Build Task. The latter can by default be called with the keybinding Ctrl + Shift + B. The build task can also be customized via a tasks.json file. This is useful if you want to pass additional arguments to test-unit-make. E.g. a build task with increased verbosity might look like follows:

{
	"type": "vtestunit",
	"label": "Vector Test Unit: Build test unit",
	"group": {
		"kind": "build",
		"isDefault": true
	},
	"problemMatcher": [],
	"args": ["--verbosity-level=3"]
}

Running a test unit

This extension provides a Test Explorer for executing the whole test unit or individual tests. It gives a visual representation of the test tree and directly shows the status of each test tree element. If your test unit uses variants, you can select a variant value in the bottom of the Test Explorer. Running tests in the Test Explorer requires at least version 18 of the Vector toolset. The resulting test report can be opened by clicking on the link in the test run output.

Test runs can be customized via a vector-test-unit-run launch configuration. You can pass additional arguments like e.g., --verbosity-level to the CLI of your CANoe Server Edition or Vector Test Unit Runner. You can also specify tasks to be run before or after a test run via the preLaunchTask and postDebugTask properties. This can be useful e.g., for starting your system under test before each test run and stopping it afterwards. A minimal launch configuration can be generated via the Run and Debug menu or, if a .vscode/launch.json file already exists in the workspace, via IntelliSense.

Example

Please refer to the documentation installed with your Vector toolset for details on how to implement test units. This chapter just provides a short example to facilitate getting started with writing test units for CANoe and Vector Test Unit Runner.

A test unit is described using a YAML file with file ending vtestunit.yaml:

version: 2.0.0

# optional section which contains information about the test unit
test-unit-information:
  description: This is an example

# list of all artifacts that belong to the test unit
test-unit-implementation:
  - source-file-path: test.can
  - source-file-path: test.vtesttree.yaml
  - capl-library-path: custom.dll

A test execution tree specifies in which order test cases and test sequences are executed. It is described using a YAML file with file ending vtesttree.yaml. It must be referenced as a source file in the vtestunit.yaml file. Test fixtures can be used to structure the test execution tree. Here is an example:

version: 2.1.0
test-tree:
  - capl-test-case: MyTestCase
    title: My Test Case Title
  - capl-test-sequence: MyTestSequence
  - test-fixture: MyTestFixture
    elements:
      - capl-test-case: MyParameterizedTestCase
        description: This is a parameterized test case
        params: [1, 2]

The actual test implementation in test.can may look like follows:

export testcase MyTestCase() {
  // TODO
}

export testcase MyParameterizedTestCase(int param1, int param2) {
  // TODO
}

export testsequence MyTestSequence() {
  // TODO
}

CANoe workflow

For Vector toolsets beginning at version 18 this extension can also be used to edit YAML-based test units in CANoe. First, you must configure Visual Studio Code as editor for test unit description files. The setting can be found in the CANoe options under External Programs > Tools > Editor for test units of format vtestunit.yaml.

Afterwards you can click the Open test design button to edit your test unit in Visual Studio Code.

The environment from your CANoe configuration (e.g., system variables and distributed objects) will be available in your test implementations.

To run your tests, please use the Test Configuration window in CANoe.

FAQ

I have just created a vtestunit.yaml or vtesttree.yaml file in my workspace but the extension does not activate. What can I do?

This extension takes .gitignore into account when finding available description files. Ensure that vtestunit.yaml or vtesttree.yaml are not excluded by .gitignore.

My C# test is not validated and there is no IntelliSense. What can I do?

• Make sure that the C# file is listed as a source file in the test unit description file.
• Make sure that the correct test unit is selected via the command Vector Test Unit: Select test unit.
• Make sure that the C# extension is installed.
• Make sure that the generated C# solution is loaded by running the command .NET: Open Solution and selecting ActiveVectorSolution.sln.
• Make sure that a .NET SDK is installed on your system. It is required by the C# extension.
• Have a look into the output of the C# extension and see if it gives any hints.

C# IntelliSense is not recognizing changes in my environment. What can I do?

In case of any troubles with C# IntelliSense, we recommend configuring the C# extension to use the OmniSharp Language Server instead of the default one. You can do this by enabling the following two workspace settings:

• dotnet.preferCSharpExtension
• dotnet.server.useOmniSharp

Please note that this will disable the C# Dev Kit in your workspace.

I have the Pylint extension installed and it shows Unable to import ... errors for the imported Vector modules. How can I fix that?

Unfortunately, the Pylint extension does not yet respect the Python environment defined via the python.envFile setting. Until the Pylint extension fixes this, you can ignore the errors by listing the modules as ignored-modules in a .pylintrc file and referencing the file in the pylint.args setting.