Test Pragmas - Revision history

Ivailop at 20:55, 17 July 2018

2018-07-17T20:55:43Z

← Older revision		Revision as of 20:55, 17 July 2018
Line 15:		Line 15:


	= scl_test_class =		== scl_test_class ==

	The ''scl_test_class'' pragma is used to declare a C++ class as a '''Test Unit'''.		The ''scl_test_class'' pragma is used to declare a C++ class as a '''Test Unit'''.
Line 73:		Line 73:


	= scl_test_cclass =		== scl_test_cclass ==

	The ''scl_test_cclass'' pragma is used to declare a "C" language struct (class) to be captured as a '''Test Unit'''.		The ''scl_test_cclass'' pragma is used to declare a "C" language struct (class) to be captured as a '''Test Unit'''.
Line 147:		Line 147:


	= scl_test_flist =		== scl_test_flist ==

	The ''scl_test_flist'' pragma is used to declare a list of external functions as a '''Test Unit'''.		The ''scl_test_flist'' pragma is used to declare a list of external functions as a '''Test Unit'''.
Line 213:		Line 213:


	= scl_test_setup =		== scl_test_setup ==

	The ''scl_test_setup'' pragma declares a member method to be a setup fixture for an existing '''Test Unit'''. The setup method will be called before the execution of each test method.		The ''scl_test_setup'' pragma declares a member method to be a setup fixture for an existing '''Test Unit'''. The setup method will be called before the execution of each test method.
Line 256:		Line 256:


	= scl_test_teardown =		== scl_test_teardown ==

	The ''scl_test_teardown'' pragma declares a member method to be a teardown fixture for an existing '''Test Unit'''. The teardown method will be called after the execution of each test method.		The ''scl_test_teardown'' pragma declares a member method to be a teardown fixture for an existing '''Test Unit'''. The teardown method will be called after the execution of each test method.

Ryanh at 16:15, 7 July 2015

2015-07-07T16:15:19Z

← Older revision		Revision as of 16:15, 7 July 2015
Line 6:		Line 6:
	#include <srtest.h>		#include <srtest.h>

	class MyTest {		class MyTest : public stride::srTest {
	public:		public:
	void CheckFoo();		void CheckFoo();
Line 30:		Line 30:
	\| ''class-name''		\| ''class-name''
	\| Identifier		\| Identifier
	\| The name of the test unit. This is must be the name of an existing C++ class or a struct.		\| The name of the test unit. This must be the name of an existing C++ class or a struct.
	\|}		\|}

Line 58:		Line 58:
	#include <srtest.h>		#include <srtest.h>

	class MyOtherTest		class MyOtherTest : public stride::srTest
	{		{
	public:		public:

Marku at 19:50, 6 July 2015

2015-07-06T19:50:28Z

← Older revision		Revision as of 19:50, 6 July 2015
Line 1:		Line 1:
	__NOTOC__		__NOTOC__
	Test Unit [http://en.wikipedia.org/wiki/Directive_(programming) pragmas] are a set of compiler directives that allow annotations within C and C++ source files that are meaningful to the Stride ~~Compiler~~ but '''ignored''' by standard C/C++ compilers. During the build process the [[Build Tools ~~\| Stride Compiler~~]] generates an [[Intercept Module]] that provides [http://en.wikipedia.org/wiki/Test_harness harnessing] for the tests. Refer to the following header file that contains the ''scl_test_class'' pragma.		Test Unit [http://en.wikipedia.org/wiki/Directive_(programming) pragmas] are a set of compiler directives that allow annotations within C and C++ source files that are meaningful to the Stride Build Tools but '''ignored''' by standard C/C++ compilers. During the build process the [[Build Tools]] generates an [[Intercept Module]] that provides [http://en.wikipedia.org/wiki/Test_harness harnessing] for the tests. Refer to the following header file that contains the ''scl_test_class'' pragma.

	'''Header file'''		'''Header file'''

Marku at 16:54, 6 July 2015

2015-07-06T16:54:35Z

← Older revision		Revision as of 16:54, 6 July 2015
Line 1:		Line 1:
	__NOTOC__		__NOTOC__
	Test Unit [http://en.wikipedia.org/wiki/Directive_(programming) pragmas] are a set of compiler directives that allow annotations within C and C++ source files that are meaningful to the Stride Compiler but '''ignored''' by standard C/C++ compilers. During the build process the [[Build Tools \| Stride Compiler]] generates [[Intercept Module~~\|IM source code~~]] that provides [http://en.wikipedia.org/wiki/Test_harness harnessing] for the tests. Refer to the following header file that contains the ''scl_test_class'' pragma.		Test Unit [http://en.wikipedia.org/wiki/Directive_(programming) pragmas] are a set of compiler directives that allow annotations within C and C++ source files that are meaningful to the Stride Compiler but '''ignored''' by standard C/C++ compilers. During the build process the [[Build Tools \| Stride Compiler]] generates an [[Intercept Module]] that provides [http://en.wikipedia.org/wiki/Test_harness harnessing] for the tests. Refer to the following header file that contains the ''scl_test_class'' pragma.

	'''Header file'''		'''Header file'''
Line 58:		Line 58:
	#include <srtest.h>		#include <srtest.h>

	class ~~RuntimeServices_dynamic~~		class MyOtherTest
	{		{
	public:		public:
	// Declaring a constructor for an scl_test_class is optional, but		// Declaring a constructor for an scl_test_class is optional, but
	// if a constructor is declared all arguments must be of plain old data (POD) type.		// if a constructor is declared all arguments must be of plain old data (POD) type.
	~~RuntimeServices_dynamic~~(int i, const char* s);		MyOtherTest(int i, const char* s);

	void ~~dynamic~~();		void CheckItOut();
	};		};
			#ifdef _SCL
	#ifdef _SCL		#pragma scl_test_class(MyOtherTest)
	#pragma scl_test_class(~~RuntimeServices_dynamic~~)
	#endif		#endif
	</source>		</source>
Line 244:		Line 243:
	#include <srtest.h>		#include <srtest.h>

	class ~~RuntimeServices_fixtures~~ {		class MyTest {
	public:		public:
	void ~~setup~~ (~~void)~~		void FooSetup();
	{		void CheckFoo();
	~~srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "setup called");~~
	}
	~~void teardown (void)~~
	{
	~~srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "teardown called");~~
	}
	~~void tc_ExpectPass(void)~~
	{
	~~srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "this test should pass");~~
	~~srTestCaseSetStatus(srTEST_CASE_DEFAULT, srTEST_PASS, 0~~);
	}
	void ~~tc_ExpectFail~~(~~void)~~
	{
	~~srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_ERROR, srNULL, "this test should fail"~~);
	~~srTestCaseSetStatus(srTEST_CASE_DEFAULT, srTEST_FAIL, 0);~~
	}
	};		};

	#ifdef _SCL		#ifdef _SCL
	#pragma scl_test_class(~~RuntimeServices_fixtures~~)		#pragma scl_test_class(MyTest)
	#pragma scl_test_setup(~~RuntimeServices_fixtures~~, ~~setup)~~		#pragma scl_test_setup(MyTest, FooSetup)
	~~#pragma scl_test_teardown(RuntimeServices_fixtures, teardown~~)
	#endif		#endif
	</source>		</source>
Line 302:		Line 284:
	=== Example ===		=== Example ===
	<source lang=cpp>		<source lang=cpp>
	~~#include <srtest.h>~~		class MyTest {

	class ~~RuntimeServices_fixtures~~ {
	public:		public:
	void ~~setup~~ (~~void)~~		void FooSetup();
	{		void FooTeardown();
	~~srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "setup called"~~);		void CheckFoo();
	}
	~~void teardown (void)~~
	{
	~~srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "teardown called");~~
	}
	~~void tc_ExpectPass(~~void)
	{
	~~srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "this test should pass");~~
	~~srTestCaseSetStatus~~(~~srTEST_CASE_DEFAULT, srTEST_PASS, 0~~);
	}
	void ~~tc_ExpectFail~~(~~void)~~
	{
	~~srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_ERROR, srNULL, "this test should fail"~~);
	~~srTestCaseSetStatus(srTEST_CASE_DEFAULT, srTEST_FAIL, 0);~~
	}
	};		};

	#ifdef _SCL		#ifdef _SCL
	#pragma scl_test_class(~~RuntimeServices_fixtures~~)		#pragma scl_test_class(MyTest)
	#pragma scl_test_setup(~~RuntimeServices_fixtures~~, ~~setup~~)		#pragma scl_test_setup(MyTest, FooSetup)
	#pragma scl_test_teardown(~~RuntimeServices_fixtures~~, ~~teardown~~)		#pragma scl_test_teardown(MyTest, FooTeardown)
	#endif		#endif
	</source>		</source>

Marku: Created page with "NOTOC Test Unit [http://en.wikipedia.org/wiki/Directive_(programming) pragmas] are a set of compiler directives that allow annotations within C and C++ source files that a..."

2015-07-06T16:18:43Z

Created page with "__NOTOC__ Test Unit [http://en.wikipedia.org/wiki/Directive_(programming) pragmas] are a set of compiler directives that allow annotations within C and C++ source files that a..."

New page

__NOTOC__
Test Unit [http://en.wikipedia.org/wiki/Directive_(programming) pragmas] are a set of compiler directives that allow annotations within C and C++ source files that are meaningful to the Stride Compiler but '''ignored''' by standard C/C++ compilers. During the build process the [[Build Tools | Stride Compiler]] generates [[Intercept Module|IM source code]] that provides [http://en.wikipedia.org/wiki/Test_harness harnessing] for the tests. Refer to the following header file that contains the ''scl_test_class'' pragma.

'''Header file'''
<source lang=cpp>
#include <srtest.h>

class MyTest {
public:
void CheckFoo();
void CheckBoo();
};
#pragma scl_test_class(MyTest)
</source>

= scl_test_class =

The ''scl_test_class'' pragma is used to declare a C++ class as a '''Test Unit'''.

=== Syntax ===

#pragma scl_test_class(class-name)

{| border="1" cellspacing="0" cellpadding="10" style="align:left;"
| '''Parameters'''
| '''Type'''
| '''Description'''
|-
| ''class-name''
| Identifier
| The name of the test unit. This is must be the name of an existing C++ class or a struct.
|}

=== Notes ===
* This pragma requires the compilation language to be C++. If the compilation language is not C++ and this pragma is encountered, then an error is issued and this pragma is ignored.

* The test class identified:
** must have single public constructor - default or explicit.
** must not be a templated class
** must not be a nested class
** must not be a pure virtual class
** must have one or more member functions that is suitable as a test method. For a member function to be a test method it:
*** must be declared within the test class (a method that is inherited from a base class cannot be a test method)
*** must be declared with public access
*** must have a return type of bool, an integral type (signed or unsigned long, int, short, char) or void.
*** must have an empty parameter list - declared as f() or f(void).
*** must not be a templatized function
*** must not be an overloaded operator
*** must not be a static member.

* Optionally if desired a set of setup/teardown fixtures could be applied.

* Optionally if desired the public constructor may have arguments (they must all be of [http://en.wikipedia.org/wiki/Null-terminated_string C-string] and numeric types).

=== Examples ===
<source lang=cpp>
#include <srtest.h>

class RuntimeServices_dynamic
{
public:
// Declaring a constructor for an scl_test_class is optional, but
// if a constructor is declared all arguments must be of plain old data (POD) type.
RuntimeServices_dynamic(int i, const char* s);

void dynamic();
};

#ifdef _SCL
#pragma scl_test_class(RuntimeServices_dynamic)
#endif
</source>

= scl_test_cclass =

The ''scl_test_cclass'' pragma is used to declare a "C" language struct (class) to be captured as a '''Test Unit'''.

=== Syntax ===

#pragma scl_test_cclass(cclass-name, init-function-name { , deinit-function-name })

{| border="1" cellspacing="0" cellpadding="10" style="align:left;"
| width="180" | '''Parameters'''
| width="60" | '''Type'''
| '''Description'''
|-
| ''cclass-name''
| Identifier
| The name of the test unit. This is must be the name of an existing struct in C/C++ or a class in C++.
|-
| ''init-function-name''
| Identifier
| The initialization function name. This is synonymous with a class constructor. There must be a prior user-declared function with this name. The first parameter must be a pointer to cclass-name. Additional parameters are left up to the user's implementation.
|-
| ''deinit-function-name (optional)''
| Identifier
| The deinitialization function name. This is synonymous with a class destructor. If declared, there must be a user-declared function with this name. The first parameter must be a pointer to cclass-name. Additional parameters are left up to the user's implementation.
|}

=== Notes ===
* The cclass-name identified:
** may not appear as a specifier of a prior pragma.
** must be a struct in C.
** must be either a struct or class in C++.
** must be [http://en.wikipedia.org/wiki/Plain_Old_Data_Structures POD] type.
** must not be a template class.
** must not be a nested class.
** must contain at least one member function pointer with a prototype that:
*** returns integral type: void, int, or bool (bool accepted only for C++).
*** has a first parameter that is a pointer to cclass-name.

* The init-function-name identified:
** must be declared prior to this pragma's declaration.
** must not have been used in any prior or subsequent SCL pragma.
** must have its first parameter declared as a pointer to the identified cclass.
** optionally if desired it may have additional parameters (they must all be of [http://en.wikipedia.org/wiki/Null-terminated_string C-string] and numeric types).

* The deinit-function-name:
** is optional.
** must be declared prior to this pragma's declaration if it appears in pragma.
** must not have been used in any prior or subsequent SCL pragma.
** must have its first parameter declared as a pointer to the identified class.

* Optionally if desired a set of setup/teardown fixtures could be applied.

=== Examples ===
<source lang=c>
#include <srtest.h>

typedef struct CClass_Basic_Simple {
int (*pf_TestMethod)(struct CClass_Basic_Simple* pcc);
} CClass_Basic_Simple;

#ifdef __cplusplus
extern "C" {
#endif
void CClass_Basic_Simple_init(struct CClass_Basic_Simple* pcc);
#ifdef __cplusplus
}
#endif

#ifdef _SCL
#pragma scl_test_cclass(CClass_Basic_Simple, CClass_Basic_Simple_init)
#endif
</source>

= scl_test_flist =

The ''scl_test_flist'' pragma is used to declare a list of external functions as a '''Test Unit'''.

=== Syntax ===

#pragma scl_test_flist(test-unit-name, function-1, function-2..n)

{| border="1" cellspacing="0" cellpadding="10" style="align:left;"
| '''Parameters'''
| '''Type'''
| '''Description'''
|-
| ''test-unit-name''
| String
| The name of the test unit. A special '''identifier''' with that name will be synthesized into which the list of external functions will be assembled.
'''''Note:''' this string may not contain a space.''
|-
| ''function-1''
| Identifier
| Name of the first external function to be captured.
|-
| ''function-2..n [Optional]''
| Identifier
| Optional names of second and subsequent external functions to be captured.
|}

=== Notes ===

* The external functions must meet the following conditions:
** Their parameter lists must be empty (void).
** They cannot be overloaded.
** They cannot be overloaded operators.
** They may not be template functions.
** They may throw exceptions when compiled in CPP mode.
** They cannot have been previously captured with the ''scl_function'' pragram or the ''scl_test_flist'' pragma.
** They cannot be ''public static class methods''.
** They must return a pass/fail result. The return type may be declared void or an integer type (bool is acceptable in C++ mode). If void is the return type, any calls to the test function default to successful.

* Once an external function has been captured with scl_test_flist, that function may not then be captured again with the ''scl_function'' pragma, or the ''scl_test_flist'' pragma, or used with any other qualification pragmas.
* Use of this pragma requires an include of ''srtest.h''.
* The test-unit-name may not have been specified with a prior scl_test_flist pragma.
* The test-unit-name may not be the name of an existing routine.
* Optionally if desired a set of setup/teardown fixtures could be applied.

=== Examples ===
<source lang=c>
#include <srtest.h>

#ifdef __cplusplus
extern "C" {
#endif

int test1();
int test2();

#ifdef __cplusplus
}
#endif

#ifdef _SCL
#pragma scl_test_flist("Foo", test1, test2)
#endif
</source>

= scl_test_setup =

The ''scl_test_setup'' pragma declares a member method to be a setup fixture for an existing '''Test Unit'''. The setup method will be called before the execution of each test method.

=== Syntax ===

#pragma scl_test_setup(test-unit-name, function-name)

{| border="1" cellspacing="0" cellpadding="10" style="align:left;"
| '''Parameters'''
| '''Type'''
| '''Description'''
|-
| ''test-unit-name''
| Identifier
| Name of a captured test unit.
|-
| ''function-name''
| Identifier
| Name of a member function of the test unit to be used as a setup fixture.
|}

=== Notes ===
* This pragma identifies the setup fixture of an existing test unit, i.e. either a class with ''scl_test_class'' applied to it, a set of functions with ''scl_test_flist'' applied to it, or a C struct with ''scl_test_cclass'' applied to it.
* There may be only one setup fixture per test unit.

=== Example ===
<source lang=cpp>
#include <srtest.h>

class RuntimeServices_fixtures {
public:
void setup (void)
{
srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "setup called");
}
void teardown (void)
{
srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "teardown called");
}
void tc_ExpectPass(void)
{
srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "this test should pass");
srTestCaseSetStatus(srTEST_CASE_DEFAULT, srTEST_PASS, 0);
}
void tc_ExpectFail(void)
{
srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_ERROR, srNULL, "this test should fail");
srTestCaseSetStatus(srTEST_CASE_DEFAULT, srTEST_FAIL, 0);
}
};

#ifdef _SCL
#pragma scl_test_class(RuntimeServices_fixtures)
#pragma scl_test_setup(RuntimeServices_fixtures, setup)
#pragma scl_test_teardown(RuntimeServices_fixtures, teardown)
#endif
</source>

= scl_test_teardown =

The ''scl_test_teardown'' pragma declares a member method to be a teardown fixture for an existing '''Test Unit'''. The teardown method will be called after the execution of each test method.

=== Syntax ===

#pragma scl_test_teardown(test-unit-name, function-name)

{| border="1" cellspacing="0" cellpadding="10" style="align:left;"
| '''Parameters'''
| '''Type'''
| '''Description'''
|-
| ''test-unit-name''
| Identifier
| Name of a captured test unit.
|-
| ''function-name''
| Identifier
| Name of a member function of the test unit to be used as a teardown fixture.
|}

=== Notes ===
* This pragma identifies the setup fixture of an existing test unit, i.e. either a class with ''scl_test_class'' applied to it, a set of functions with ''scl_test_flist'' applied to it, or a C struct with ''scl_test_cclass'' applied to it.
* There may be only one teardown fixture per test unit.

=== Example ===
<source lang=cpp>
#include <srtest.h>

class RuntimeServices_fixtures {
public:
void setup (void)
{
srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "setup called");
}
void teardown (void)
{
srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "teardown called");
}
void tc_ExpectPass(void)
{
srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_INFO, srNULL, "this test should pass");
srTestCaseSetStatus(srTEST_CASE_DEFAULT, srTEST_PASS, 0);
}
void tc_ExpectFail(void)
{
srTestCaseAddAnnotation(srTEST_CASE_DEFAULT, srTEST_ANNOTATION_LEVEL_ERROR, srNULL, "this test should fail");
srTestCaseSetStatus(srTEST_CASE_DEFAULT, srTEST_FAIL, 0);
}
};

#ifdef _SCL
#pragma scl_test_class(RuntimeServices_fixtures)
#pragma scl_test_setup(RuntimeServices_fixtures, setup)
#pragma scl_test_teardown(RuntimeServices_fixtures, teardown)
#endif
</source>

Test Pragmas - Revision history

Ivailop at 20:55, 17 July 2018

Ryanh at 16:15, 7 July 2015

Marku at 19:50, 6 July 2015

Marku at 16:54, 6 July 2015

Marku: Created page with "__NOTOC__ Test Unit [http://en.wikipedia.org/wiki/Directive_(programming) pragmas] are a set of compiler directives that allow annotations within C and C++ source files that a..."

Marku: Created page with "NOTOC Test Unit [http://en.wikipedia.org/wiki/Directive_(programming) pragmas] are a set of compiler directives that allow annotations within C and C++ source files that a..."