Using CANoe .NET API 
Version 2.7 
2016-02-18 
Application Note AN-IND-1-011 
Author 
Åsa Björnemark, Andreas Armbruster, Gunnar Stein 
Restrictions Public Document 
Abstract 
Describes CANoe .NET API usage details 
Table of Contents 
1.0
Document History ......................................................................................................................... 2
2.0
Glossary ......................................................................................................................................... 2
3.0
Introduction ................................................................................................................................... 3
3.1.1
Prepare Visual Studio to be used as .NET Editor ................................................................ 3
3.1.2
Add a .NET Test Module ...................................................................................................... 3
3.1.3
Create a CANoe configuration specific .NET Test Library................................................... 4
3.1.4
Create a .NET Test Library that is independent from a CANoe configuration ..................... 5
3.1.5
Next Steps ............................................................................................................................ 5
4.0
Environment .................................................................................................................................. 6
4.1
CANoe .NET API Components ............................................................................................ 6
4.2
.NET Editor ........................................................................................................................... 7
4.3
.NET Programs in CANoe .................................................................................................... 7
4.3.1
.NET Test Modules .............................................................................................................. 8
4.3.2
.NET Simulation Nodes ........................................................................................................ 8
4.3.3
.NET Snippets ...................................................................................................................... 8
4.3.4
.NET Test Libraries .............................................................................................................. 8
4.3.5
.NET Test Module and CAPL Test Cases / Test Functions ..............................................10
4.3.6
.NET Test units ..................................................................................................................10
4.4
Additional Information and CANoe Examples ....................................................................11
5.0
Programming with the CANoe .NET API ...................................................................................11
5.1
Common Features .............................................................................................................11
5.1.1
Signals (bus signals, environment and system variables) .................................................11
5.1.2
Messages ...........................................................................................................................12
5.1.3
Timer ..................................................................................................................................12
5.1.4
Event Procedures...............................................................................................................13
5.2
Test Features .....................................................................................................................14
5.2.1
Test Module Types ............................................................................................................14
5.2.2
Reporting Commands ........................................................................................................16
5.2.3
Wait Points .........................................................................................................................16
5.2.4
Checks ...............................................................................................................................17
5.2.5
Criterions ............................................................................................................................18
5.2.6
User Dialogs .......................................................................................................................19
5.2.7
Test Patterns ......................................................................................................................19
5.2.8
Diagnostic Tests.................................................................................................................20
6.0
Migrating a .NET Module that was created with CANoe < 7.6SP3..........................................21
6.1
Migrating from .NET2 API to .NET4 API ............................................................................21
6.1.1
Migrating the CANoe configuration ....................................................................................21
Convert pdf file to txt - Convert PDF to txt files in C#.net, ASP.NET MVC, WinForms, WPF application
C# PDF to Text (TXT) Converting Library to Convert PDF to Text
changing pdf to text; convert pdf photo to text
Convert pdf file to txt - VB.NET PDF Convert to Text SDK: Convert PDF to txt files in vb.net, ASP.NET MVC, WinForms, WPF application
VB.NET Guide and Sample Codes to Convert PDF to Text in .NET Project
convert pdf to openoffice text document; convert pdf to word text online
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
2 
Contact Information:   www.vector.com   or +49-711-80 670-0 
6.1.2
Migrating .NET Test Modules and Test Libraries ..............................................................21
7.0
Background Information (for Experts) ......................................................................................22
7.1
Real-time Performance ......................................................................................................22
7.2
Concurrency .......................................................................................................................22
7.3
Debugging .NET Programs ................................................................................................23
7.4
Post-compilation.................................................................................................................23
7.5
Troubleshooting .................................................................................................................24
7.5.1
Debug Information not visible (breakpoints not hit) ...........................................................24
7.5.2
Intellisense not active in Visual Studio ...............................................................................24
7.5.3
Warning in Write window using a Test Case Library .........................................................24
7.5.4
Visual Studio cannot build because annother process holds the .NET assembly .............24
7.5.5
You encounter build errors due to wrong API versions .....................................................24
8.0
Additional Resources .................................................................................................................24
9.0
Contacts .......................................................................................................................................24
1.0 Document History 
Version 2.7 
New document template and minor changes. 
Version 2.6 
.NET4 support, test units, post compiler. 
Version 2.5 
Glossary updated, minor changes. 
Version 2.4 
Note about .NET framework version added (chapter 3.0) 
Version 2.3 
Project templates for .NET test libraries that are independent from CANoe’s configurations 
Version 2.2 
Document structure revised 
Glossary added 
Quick start instructions (chapter 0) 
.NET test libraries for XML and .NET test modules (chapter 4.3.4) 
Overview of reporting elements (chapter 5.2.2) 
Diagnostic tests (chapter 5.2.8) 
2.0 Glossary 
CANoe .NET API 
A set of .NET assemblies (.dlls) providing access to CANoe’s functionality. 
CAPL Library 
A collection of CAPL test cases and test functions that can be used from your .NET program. 
Snippet 
A small piece of .NET program code that can be executed like a macro. Snippets can be changed and 
recompiled while measurement is running. 
Online Convert PDF to Text file. Best free online PDF txt
from other C# .NET PDF to text conversion controls, RasterEdge C# PDF to text converter control toolkit can convert PDF document to text file with good
convert pdf to text online; convert pdf file to text online
VB.NET Create PDF from Text to convert txt files to PDF in vb.net
Batch convert editable & searchable PDF document from TXT formats in VB.NET class. Able to copy and paste all text content from .txt file to PDF file by keeping
convert pdf image to text; convert pdf picture to text
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
3 
Contact Information:   www.vector.com   or +49-711-80 670-0 
.NET Test Library 
A .NET assembly containing further test cases, test functions or customer specific methods. A .NET 
Test Library is added as a component to a .NET or XML test module. 
Runtime Values 
Objects that represent signals, system variables and environment variables. 
Type Library 
A library that is generated by CANoe. It contains configuration specific data type definitions to 
comfortably access frames, signals, environment variables, system variables and CAPL library 
function from your .NET program. 
Post compilation 
After the .NET compilation a post compiler compiles the .NET assembly for a second time and adds 
code to control the test execution, error handling.   
3.0 Introduction 
The CANoe environment provides a .NET API to be used for simulation, test, and snippet 
programming. The CANoe .NET API is an Embedded Domain Specific Language extension that offers 
the possibility to use object-oriented programming languages, e.g. C# in the CANoe environment. 
.NET languages provide extended capabilities to structure, to reuse and to debug programs.  
This document uses C# as recommended programming language. Nevertheless also other .NET 
languages like Visual Basic .NET can be used. 
CANoe currently supports the .NET4 framework. 
A .NET 2 version of the CANoe API is still provided for binary compatibility to your existing DLLs. If 
you have the sources it is recommended to switch to the .NET 4 API version, since the .NET 2 API is 
fixed to the functional range of CANoe 8.2 SP2. Further development will only support the .NET 4 API. 
The .NET API can be used as an alternative to CAPL for test module or simulated node programming. 
It can also be used for programming so-called snippets, mainly used for simple stimulation or 
initialization purposes. 
Discussed in this document is the .NET API concept and its usage in CANoe. It is assumed that the 
reader is familiar with the .NET framework and the application note AN-IND-1-002 Testing with 
CANoe
This document does not primarily addresses test unit developers. However the chapters 5.0 and 7.0 
are also relevant for test unit development.Quick Start  
3.1.1 Prepare Visual Studio to be used as .NET Editor 
1. Open the CANoe Options dialog (menu: Configuration | Options | External Programs | Tools) 
2. On entry ‘.Net file Editor’, click on ‘…’. 
3. Select ‘Exec32\Scripts\Edit_NET_Source_with_VS_20xx.vbs’ from your CANoe installation folder 
(You need to adapt the file mask first to ‘All files *.*’). To use the .NET4 framework at least 
VS2010 is required. 
4. Confirm with ‘OK’. 
3.1.2 Add a .NET Test Module  
A new .NET test module shall be added to an existing CANoe configuration. 
5. Open the context menu with a right mouse click in the Test Setup.  Select “Insert .NET Test 
Module”. 
C# Create PDF from Text to convert txt files to PDF in C#.net, ASP
message can be copied and pasted to PDF file by keeping NET class source code for creating PDF document from Convert plain text to PDF text with multiple fonts
convert pdf to text format; convert pdf to plain text
C# WPF PDF Viewer SDK to convert and export PDF document to other
2. To TIFF. Export PDF to TIFF file format. 3. To TXT. Export and convert PDF to TXT file. 4. To Image. Convert PDF to image formats, such as PNG, JPG, BMP and
c# convert pdf to text file; convert pdf to word editable text
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
4 
Contact Information:   www.vector.com   or +49-711-80 670-0 
6. Open the configuration dialog for the new test module. Enter a new test module name and a new 
source file name with a ‘.cs’ extension. 
7. Click on ‘Edit’. 
The test module skeleton and a solution is created and opened in Visual Studio. User added code is 
shown in bold and demonstrates some basic CANoe .NET API features. 
using System; 
using Vector.Tools; 
using Vector.CANoe.Runtime; 
using Vector.CANoe.Threading; 
using Vector.Diagnostics;  
using Vector.Scripting;
using Vector.Scripting.UI; 
using Vector.CANoe.TFS; 
using NetworkDB; 
public class tester : TestModule 
public override void Main() 
// test sequence definition:  
SimpleTest(); 
// Test cases need to be marked with an attribute: 
[TestCase("Simple Test")] 
public void SimpleTest() 
Report.TestStep("Start engine:"); 
// Setting bus signal SigStart to 1: 
NetworkDB.database1.SigStart.Value = 1; 
// Waiting 500ms for the SigEngine signal being 1: 
if (Execution.Wait<NetworkDB.database1.SigEngine>(1, 500) == 1) 
Report.TestStepPass("Engine is running."); 
else 
Report.TestStepFail("Engine is not running."); 
}  
3.1.3 Create a CANoe configuration specific .NET Test Library  
A new .NET Test Library shall be added to an XML test module. The library project shall contain all 
references to type libraries that are specific for the CANoe configuration. 
8. Configure a temporary .NET test module in your CANoe configuration as described in 3.1.2. 
CANoe creates a solution with all references. 
9. Remove the temporary .NET test module and continue implementation of the library functions with 
Visual Studio and the solution. The test library assembly must be located in the same folder as the 
XML test module. 
10. With the ‘Component’ tab in the XML or .NET test module configuration dialog the test library 
assembly can be added. All test cases and functions are shown in the Test Automation Editor or 
are available in your .NET tester. 
The .NET Test Library class does not need to derive from Test Module and to implement Main(). The 
example below shows the library with a test case and a test function: 
using System; 
using Vector.Tools; 
using Vector.CANoe.Runtime; 
using Vector.CANoe.Threading; 
using Vector.Diagnostics; 
using Vector.Scripting; 
using Vector.Scripting.UI; 
using Vector.CANoe.TFS; 
VB.NET PDF - Convert PDF with VB.NET WPF PDF Viewer
2. To TIFF. Export PDF to TIFF file format. 3. To TXT. Export and convert PDF to TXT file. 4. To Image. Convert PDF to image formats, such as PNG, JPG, BMP and
convert pdf to rich text format online; .net extract text from pdf
C# PDF Converter Library SDK to convert PDF to other file formats
Allow users to convert PDF to Text (TXT) file. It's easy to be integrated into your C# program and convert PDF to .txt file with original PDF layout.
convert pdf to txt file format; convert pdf to ascii text
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
5 
Contact Information:   www.vector.com   or +49-711-80 670-0 
using Vector.CANoe.VTS; 
using NetworkDB; 
public class NetLibrary  
// Test cases need to be marked with an attribute: 
[TestCase("Simple Test")] 
public void SimpleTest() 
// test case as shown for a .NET test module, see above 
[TestFunction("SetValue")] 
public void SetValue(int a)  
NetworkDB.database1.SigStart.Value = a; 
Note:  
this section does not apply to test units. 
3.1.4 Create a .NET Test Library that is independent from a CANoe configuration 
This chapter describes how to create a test library that is independent from the CANoe’s configuration, 
i.e. it does not need references to configuration dependent type libraries. As an advantage such a 
library can be used in any CANoe configuration but some special handling is necessary when 
accessing configuration specific data, e.g. signals.  
Visual Studio will offer a .NET test library template project when you copy  
C:\...\CANwin Demos\Demo_Addon\VS_DotNetTestLibary_Template\CANoe DotNet Test Library.zip 
to your Visual Studio CSharp Project Template folder, typically located here:  
C:\Users\<username>\Documents\Visual Studio <vs_version>\Templates\ProjectTemplates\Visual C# 
You can check the template folder in your Visual Studio Options dialog (menu: Projects and Solutions | 
General | User project templates location). 
At next a new .NET test library can be created in Visual Studio with menu: File | New | Project | Visual 
C# and selecting 'CANoe DotNet Test Library'. Before confirming the dialog with ‘OK’ you should 
select a library name and the folder. 
After a first compilation the assembly can be added to the XML tester components. 
Note:  
this section does not apply to test units. 
3.1.5 Next Steps 
Change the test module to a structured Test Module that allows to enable individual test cases 
(chapter  5.2.1) 
Create test cases, test groups and define the execution sequence  (chapter  5.2.1) 
Manipulate signals and  environment  variables  (chapter 5.1.1) 
Verification of signals and environment  variables  (chapter 5.2.2), verdict generation and reporting 
(chapter 5.2.2) 
Setting up background checks (chapter 5.2.4) 
VB.NET PDF - WPF PDF Viewer for VB.NET Program
are allowed to view PDF on VB.NET project, annotate PDF document with various notes and shapes, convert PDF to Word document, Tiff image, TXT file and other
extract text from pdf; convert pdf to txt format online
C# TIFF: Use C#.NET Code to Extract Text from TIFF File
oPage.SaveTo(MIMEType.TXT, outputTxt demonstrates how to extract the first page text from a multi-page TIFF file, and then save the result as a pdf file.
convert pdf to editable text online; batch pdf to text
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
6 
Contact Information:   www.vector.com   or +49-711-80 670-0 
4.0 Environment 
4.1 CANoe .NET API Components 
Two groups of assemblies build the .NET API and are needed for compilation of your .NET program: 
CANoe programming interface 
These assemblies provide access to CANoe functionality. They are copied from the CANoe 
installation to the .NET solution folder in case of building the assembly from within Visual Studio. 
Nevertheless the solution will still refer to the assemblies of the CANoe installation. 
Type libraries 
They are dynamically generated by CANoe and ensure type-safe and  convenient access to 
database signals, messages etc. Type libraries are automatically updated when the underlying 
data is changed.  
Database object will be represented by a class under the namespace NetworkDB. Environment 
variables are directly accessible under this namespace while message objects are always created 
in a subordinate namespace called Frames to prevent possible conflicts with signal classes. In 
case of name ambiguities of signals or messages, the namespaces of the generated libraries (e.g. 
qualification of signals --> DB.Node.Message.Signal) can be adjusted in the Options dialog in 
CANoe (menu: Configuration | Options | Programming | .NET). After changes are made in this 
dialog CANoe will regenerate the type libraries automatically. System variables are created under 
the user chosen namespaces.  
When editing a .NET program (IDE started with CANoe) and no solution is found in the configuration 
folder CANoe creates a solution with all needed API references. 
Note 
CANoe supports generation but not modification of the VS solution/project file.  If more 
components are added in the node configuration dialog or if a new database is added, these 
libraries must be added manually as references to the VS project. 
In the following all type libraries and their functionality is described: 
Vector.Tools  
Contains the shared API for the Vector tools, e.g. printing to the write window, measurement time 
access and timer management. 
Vector.Tools.Internal 
Internal CANoe interface used by Vector.Tools 
Vector.CANoe.Runtime  
Contains the interfaces and classes implemented by the CANoe runtime environment, e.g. event 
handler  
Vector.CANoe.Runtime.Internal 
Internal CANoe interface used by Vector.CANoe.Runtime. 
Vector.CANoe.TFS  
Contains the interfaces of the Test Feature Set used for test modules 
Vector.CANoe.TFS.ITE  
Contains the interfaces of the Test Feature Set used for test units. 
Vector.CANoe.TFS.Internal  
Internal CANoe interface used by Vector.CANoe.TFS.and Vector.CANoe.TFS.ITE 
Vector.CANoe.Threading  
Contains the interfaces for e.g. wait commands, wait conditions and user input dialogs. 
Vector.Diagnostics  
Contains the interfaces of the Diagnostic Feature Set.  
Vector.Scripting.UI 
Contains further user dialogs for test nodes and .NET snippets. 
Vector.CANoe.VTS 
Contains the API to access VT Systems. 
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
7 
Contact Information:   www.vector.com   or +49-711-80 670-0 
Vector.CANoe.Sockets 
Contains network access functionality. 
<DB name>.dll  
For all messages and signals and environment variables in the CAN database this assembly 
contains class definitions. The assembly is automatically generated and updated by CANoe. 
<configuration name>.cfg_sysvars.dll  
This assembly contains class definitions for all system variables used in the configuration file. The 
assembly is automatically generated by CANoe. 
<system variable file>.dll  
For each external system variable file CANoe creates a library file to access the system variables. 
<program name>_CaplLibraries.dll  
Contains the functions to access CAPL test cases and test functions from within .NET test 
modules 
For a complete API description please check the CANoe online help. 
Note1:  
All .NET programs are executed in the runtime environment of CANoe and can slow down or 
even block the simulation.  
Note2: 
This document describes the .NET API available with CANoe version 8.2.  
Note3: 
For older versions some restrictions apply, please refer to the online help for detailed 
information 
The .NET2 API additionally uses PostSharp.Public and PostSharp.Laos for post compilation purposes. 
They are not used in the .NET4 API anymore. 
4.2 .NET Editor 
Visual Studio .NET 2005 - 2013 can be used as IDE for .NET programs in CANoe. All IDEs are 
supported in CANoe by Visual Basic scripts that facilitate the automatic creation of solutions, project 
references, access to type libraries etc. 
The open source environment SharpDevelop could be used as an alternative to Visual Studio but 
there is no script to support this IDE. The user must configure the environment manually, e.g. add all 
references etc. 
To configure the .NET editor to be used in CANoe use the Options dialog (menu: Configuration | 
Options | External Programs | Tools | .NET file editor) and select the script (vbs file) matching your 
Visual Studio version. The available scripts for Visual Studio are delivered with the CANoe installation 
and located in the folder <CANoe installation path>\Exec32\Scripts. 
Note:  
It is important to configure the vbs script, and not the exe file of the editor, in CANoe.  
4.3 .NET Programs in CANoe 
Programs for network and test nodes can be specified in the node configuration dialog as .cs (C# 
source file), .dll (assembly) or .sln (a solution file). 
A source file or a solution is used when the code should be visible and editable for the CANoe user.  
Configuring a source file has the advantage that a solution with correct references is created for the 
module while this is not the case when you configure a solution. 
One reason for using an assembly file might be to hide the information on how the module was 
programmed, or to restrain changes to the code. Note that the assembly must be rebuilt if the 
generated type libraries have changed. Please consider also the post compilation of assemblies (see 
also section 7.4). 
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
8 
Contact Information:   www.vector.com   or +49-711-80 670-0 
A solution file should be used if the .NET program is subdivided in several source files or modules. It is 
recommended to let CANoe create the solution automatically. This is done by configuring a non-
existing solution file name in the test module/node configuration dialog in CANoe and pressing the 
[Edit] button. The generated solution is opened with the chosen IDE, including all correct settings. 
4.3.1 .NET Test Modules 
Test modules should be added to the test environment in the Test Setup (see also AN-IND-1-002 
Testing with CANoe). After adding a test module, you can right-click with mouse on the test module 
and choose Configuration… to specify the .NET file. CANoe will generate a skeleton of an 
unstructured test module when you edit it for the first time. 
A .NET test module must be derived from the class 
Vector.CANoe.TFS.TestModule or 
Vector.CANoe.TFS.StructuredTestModule
Please find more info about test modules in chapter 5.2. 
4.3.2 .NET Simulation Nodes 
Simulated network nodes should be added to the Simulation Setup. After adding a simulated node, 
you can right-click with the mouse and choose Configuration… to configure the .NET file. CANoe will 
generate a skeleton file when you edit it for the first time. 
A .NET simulated network node must inherit from the class
Vector.CANoe.Runtime.MeasurementScript. 
Then you can handle measurement events like 
start/stop of measurement.  
Note:  
Types from Vector.CANoe.Threading, Vector.CANoe.TFS and Vector.Diagnostics cannot be 
used in simulated network nodes. 
4.3.3 .NET Snippets 
Snippets are small procedures that are often used for interactive test stimulation and/or initialization. 
Typically a snippet consists of one small function.  
Snippets can be configured in the Macro and .NET Snippet Configuration dialog, under Configuration | 
Macro… Add a snippet by the button [Add] and configure the .NET source file here. Several snippets 
can be added in the list.  
All public methods without parameters and without return value that are members of a public class in 
the .NET snippet file, are treated as snippets. 
Macros and snippets can be run interactively. Snippets that are not running can be edited and 
compiled during measurement. Wait functions can be used in snippets and event handlers are active 
when the snippet is running. 
Some restrictions apply to snippet programming (e.g. report methods cannot be used) – please see 
the CANoe online help for further information. 
To learn more about the macros, and its configuration dialog, please refer to CANoe online help. 
Note:  
Types from Vector.CANoe.TFS cannot be used in snippets. 
4.3.4 .NET Test Libraries 
In contrast to normal .NET Test Libraries a .NET test library uses the CANoe .NET API and contains 
CANoe test cases respective test functions. Test cases and test functions from .NET test library can 
be invoked in XML and .NET test modules. A .NET test module - and not an XML Test module - can 
use normal .NET Test Libraries as well. 
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
9 
Contact Information:   www.vector.com   or +49-711-80 670-0 
You can implement a test library that is independent from the CANoe configuration (see 3.1.4) or a 
library that contains references to the type libraries specific for a CANoe configuration, see 3.1.3. 
A .NET test library consists of a public class which doesn’t need to derive from any Vector API class 
and which does not need to implement the main() method. All public member functions with dedicated 
parameters and without return value that are marked with the TestCase or TestFunction are available 
in the test module. Event procedures in the .NET Test Library are only called during runtime of the 
.NET test case.  
The resulting test library assembly can be added to an XML or .NET test module via the component 
tab of the node configuration dialog.  The test library assembly must be located in the same folder as 
the test module. 
When a test library itself references further assemblies these assemblies should be declared in the 
node configuration dialog. This way CANoe will be able to transfer all components when the simulation 
process is executed on a remote computer. 
Note  
All .NET Test Libraries under the Component tab in Test Module Configuration dialog will be 
added as references to the VS project of the test module, as long as they were configured 
before the creation of the test module project file. 
It is important to differ between a .NET test module 
(Main()
method is also implemented in .NET) and 
an XML test module with a .NET test case library. 
In a.NET test module all variables are valid during the whole test. But if test cases from a library are 
used in an XML test module the test cases are independent from each other, i.e. each test case is 
instantiated once and variables are valid during test execution. 
It should be noted that test cases implemented in a library may be called in an arbitrary sequence and 
should be treated according to this principle (initialization, usage, cleanup). 
XML test module using .NET Test Libraries 
.NET test cases are called within a 
<nettestcase>
XML element: 
<testmodule title="Central locking system test" version="1.0"> 
<testgroup title="Test lock states of the car"> 
<nettestcase name="Execute" title="Lock the car at great velocities" 
class="LockStateDependsOnlyOnVelocity" assembly="TestLibrary"> 
<netparam type="float" name="ds">5.5</netparam> 
</nettestcase> 
</testgroup> 
</testmodule> 
.NET test functions are called with a 
<nettestfunction>
XML element inside XML test cases. It is 
possible to call several different test functions within the same test case. 
<testcase title="My Test case Title" ident=""> 
class="LockStateDependsOnlyOnVelocity" assembly="TestLibrary"> 
<netparam type="int" name="myInt">10</netparam> 
</nettestfunction> 
</testcase> 
name: specifies the name of the test case (mandatory) 
title: used for reporting and visualization (optional) 
class/assembly: used to identify the test cases (optional) 
Using CANoe .NET API
Copyright © 2016 - Vector Informatik GmbH 
10 
Contact Information:   www.vector.com   or +49-711-80 670-0 
Parameter types can be numerical values, strings, signals, environment and system variables. 
XML type 
.NET type 
int 
UInt64, UInt32, UInt16, Int64, Int32, Int16 
float 
Double 
string 
String 
signal 
Vector.CANoe.Runtime.Signal 
envvar 
Vector.CANoe.Runtime.EnvironmentVariable 
sysvar 
Vector.CANoe.Runtime.SystemVariableBase 
In contrast to the value types (int, float, string), the signal types are declared as Generics in the test 
case. Constraints must be applied to these Generics in order to guarantee type reliability. The specific 
types Signal, EnvironmentVariable or SystemVariableBase can be used for this. 
The following definition is required if you want to use a test case for all three signal types similarly: 
[TestCase] 
public void SetSignal<T>(Double d) where T : class, IRuntimeValue 
RuntimeObject<T>.Value = d; 
4.3.5 .NET Test Module and CAPL Test Cases / Test Functions 
CAPL files can be assigned to a .NET test module with the test module configuration dialog. All CAPL 
test functions and test cases can be called from the .NET test module. 
Not all CANoe features are available in the .NET API (this especially concerns bus system specifics) 
but with CAPL test libraries you can easily access the complete functionality. 
CAPL libraries that are assigned to the .NET test module are structured like CAPL test modules, but 
they must not contain a 
MainTest()
routine. Event procedures are only called during runtime of the 
.NET test module. All event procedures of the assigned CAPL libraries are considered except ‘on start’ 
and ‘on stop’. 
CAPL test cases and test functions may use parameter types ‘char, char[], byte, int, long, float, 
double’. Results can be returned via system or environment variables.  
A CAPL test case or test function can be called like any other .NET method. If they are used in 
structured test module they have to be wrapped by a .NET test case or a TestGroup method.  
CaplTestCases.CaplTestLib.MyTestCase(“test”);         
CaplTestFunctions.CaplTestLib.MyTestFunction(23.0); 
Both have been defined in a CAPL library “CaplTestLib.can” and a reference for this library is 
configured in the .NET solution. The CAPL library looks like this: 
testcase MyTestCase (char s[]) 
… 
testfunction MyTestFunction (double d) 
… 
4.3.6 .NET Test units 
Test units also use the CANoe .NET API. To create a test unit the Vector tool vTESTstudio is required. 
A detailed description of test units can be found in the vTESTstudio documentation. 
Documents you may be interested
Documents you may be interested