Parameterized Test Units

You can leverage the tests you write in Test Units by using STRIDE's parameterization feature. This allows you to supply parameters to your test units at run time to customize test behavior.

How Parameters are Passed from the Host

Parameters to be passed to a target test unit are supplied on the stride.exe command line used to invoke the test unit. Test unit parameter values are specified between parentheses characters immediately following the test unit name on the command line.

Number Parameter

For example, assume that you have a test unit implemented on the target named MyTest and it has been coded to accept a single integer parameter. To run this test unit with the parameter value 17, use the following run specification:

 --run=MyTest(17)

String Parameter

As a second example, consider a test unit coded to take a single string as a parameter. The parameter is supplied as follows:

 --run=MyOtherTest(\"string\")

Note that the string parameter must be enclosed with double quote characters. The double quotes are escaped with a backslash as this is required by the command line processor.

Parameter Containing Spaces

When the string parameter contains one or more spaces, the command processor further requires you to enclose the entire --run argument in double quotes as follows:

 --run="MyOtherTest(\"this is the parameter\")"

Note that the command line processor requires you to enclose with double quotes if there are any spaces at all in the --run argument. This can be counter-intuitive when passing only number types.

No space in argument list

 --run=TestX(123,555,3.14)

Space in argument list

 --run="TestX(123, 555, 3.14)"

Multiple Parameters

You may pass any number of parameters to a test unit, and each parameter may be of any supported type. An example is shown below:

 --run="YetAnotherTest(19.58, -1, \"Encinitas\", 92024, \"south\")"

A few additional examples are shown on the STRIDE Test Runner Reference page.

How Parameters are Received on the Target

Parameters are passed from the stride.exe command line and are presented on the target as follows:

C++ test unit

Parameters are presented as constructor arguments to the test unit class

C-Class test unit

Parameters are presented as arguments to the Initialization function.

Flist test unit

Not supported

C++ Test Unit

When using parameters with a C++ test unit, you declare and implement a public constructor that takes the number and type of arguments you want to receive.

Important: Do Not declare or implement a default constructor (constructor taking no arguments) in a class that gets parameters.

MyTest.h

#include <srtest.h>

class MyTest : public stride:srTest
{
public;
    MyTest(int nParam, const char* szParam)
    {
        // typically, you will store parameter values into member variables for use by
        // the member test methods
        m_nParam = nParam;
        strncpy(m_szParam, szParam, MAX_LEN);
    }

    // Tests
    void Test1();
    ...
    ...
    ...
private:
    int m_nParam;
    char m_szParam[MAX_LEN];
};

#ifdef _SCL
#pragma scl_test_class(MyTest)
#endif

C-Class Test Unit

MyTest.h

#include <srtest.h>
  
typdef struct MyTest
{
    int m_nParam;
    char m_szParam[MAX_LEN];

    void (*Test1)(struct MyTest* self);
    ...
    ...
    ...
} MyTest;

void MyTest_Init(MyTest* self, int nParam, const char* szParam);

#ifdef _SCL
#pragma scl_test_cclass(MyTest, MyTest_Init)
#endif

MyTest.c

#include  "MyTest.h"
 
static void Test1(MyTest* self)
{
    ...
    ...
    ...
}

/* other test implementations */
...
...
...


void MyTest_Init(MyTest* self, int nParam, const char* szParam)
{
    self->m_nParam = nParam;
    strncpy(self->m_szParam, szParam, MAX_LEN);

    self->Test1 = Test1;
    ...
    ...
    ...
}

Supported Parameter Types

ANSI strings and number parameter types are directly supported.

String types	char* const char*
Number types	all integer types float double