Using Test Doubles - Revision history

Marku: /* Creating Double Intercepts in the IM */

2015-07-06T20:08:38Z

Creating Double Intercepts in the IM

← Older revision		Revision as of 20:08, 6 July 2015
Line 70:		Line 70:

	==Creating Double Intercepts in the IM==		==Creating Double Intercepts in the IM==
	If a function has been configured as a double candidate using the function pragma as outlined in the above step, the [[Build_Tools\|~~STRIDE build tools~~]] will automatically create the [[Intercept Module]], aka IM, that contains the intercept for the double function. This all happens automatically during the build process.		If a function has been configured as a double candidate using the function pragma as outlined in the above step, the [[Build_Tools\|Stride Build Tools]] will automatically create the [[Intercept Module]], aka IM, that contains the intercept for the double function. This all happens automatically during the build process.

	But to enable the interception the source file containing the <tt>depend()</tt> implementation '''must be altered''' to [[Name_Mangling\|mangle the function's name]] by defining the Group ID and including the generated Intercept Module header file (xxxIM.h):		But to enable the interception the source file containing the <tt>depend()</tt> implementation '''must be altered''' to [[Name_Mangling\|mangle the function's name]] by defining the Group ID and including the generated Intercept Module header file (xxxIM.h):
Line 86:		Line 86:
	}		}
	</source>		</source>


	==Switching the Double Function During Runtime==		==Switching the Double Function During Runtime==

Marku at 15:29, 2 July 2015

2015-07-02T15:29:45Z

← Older revision		Revision as of 15:29, 2 July 2015
Line 48:		Line 48:
	==Configuring the Double Using Function Pragma==		==Configuring the Double Using Function Pragma==

	The syntax of the [[Scl_function\|~~scl_function~~]] ~~pragma~~ supports a set of '''''optional''''' attributes that allow the specification of function interception parameters. When captured for the purpose of interception ('''intercept-able''') the optional arguments are '''required'''.		The syntax of the [[Scl_function\|function pragma]] supports a set of '''''optional''''' attributes that allow the specification of function interception parameters. When captured for the purpose of interception ('''intercept-able''') the optional arguments are '''required'''.

	#pragma scl_function(function-name [,context, name-mangling, group-id])		#pragma scl_function(function-name [,context, name-mangling, group-id])
Line 59:		Line 59:


	In the above sample, ''depend()'' needs to be captured via the pragma and enabled for interception in a manner ~~to be doubled~~.		In the above sample, ''depend()'' needs to be captured via the pragma and enabled for interception in the following manner.

	<source lang="c">		<source lang="c">
Line 67:		Line 67:
	#pragma scl_function(depend, "DEFINITION", "IMPLICIT", "TEST_GROUP")		#pragma scl_function(depend, "DEFINITION", "IMPLICIT", "TEST_GROUP")
	</source>		</source>


	==Creating Double Intercepts in the IM==		==Creating Double Intercepts in the IM==

Marku: /* Configuring the Double Using Function Pragma */

2015-07-02T15:26:01Z

Configuring the Double Using Function Pragma

← Older revision		Revision as of 15:26, 2 July 2015
Line 48:		Line 48:
	==Configuring the Double Using Function Pragma==		==Configuring the Double Using Function Pragma==

	The syntax of the [[Scl_function\|scl_function]] pragma supports a set of '''''optional''''' attributes that allow the specification of function interception parameters.		The syntax of the [[Scl_function\|scl_function]] pragma supports a set of '''''optional''''' attributes that allow the specification of function interception parameters. When captured for the purpose of interception ('''intercept-able''') the optional arguments are '''required'''.

			#pragma scl_function(function-name [,context, name-mangling, group-id])


			Refer to the actual [[Scl_function \| function pragma]] definition for an explanation of
			* '''context''' - set to ''DEFINITION'' or ''REFERENCE''
			* '''name-mangling''' - set to ''EXPLICIT'' or ''IMPLICIT''. Note if set to explicit requires usage of the ''srTEST_INTERCEPT'' macro
			* '''group-id''' - user defined to enable or disable interception


	In the above sample, ''depend()'' needs to be captured via the pragma and enabled for interception in a manner to be doubled.		In the above sample, ''depend()'' needs to be captured via the pragma and enabled for interception in a manner to be doubled.
Line 58:		Line 67:
	#pragma scl_function(depend, "DEFINITION", "IMPLICIT", "TEST_GROUP")		#pragma scl_function(depend, "DEFINITION", "IMPLICIT", "TEST_GROUP")
	</source>		</source>


	==Creating Double Intercepts in the IM==		==Creating Double Intercepts in the IM==

Marku at 15:09, 2 July 2015

2015-07-02T15:09:15Z

← Older revision		Revision as of 15:09, 2 July 2015
Line 1:		Line 1:
	__NOTOC__		__NOTOC__
	The ''Test Double'' feature provides a means for intercepting C/C++ language global functions on the target, and directing the call to a substitute function with identical parameters and return value. The use case is a unit test where the function under test uses a ~~(global)~~ function during its execution, and this dependency is simulated by a substitute or double function during testing. The unit test is able to control the substitution of the dependency during run time, and thereby verify the behavior of the function under test.		The ''Test Double'' feature provides a means for intercepting C/C++ language '''global functions''' on the target, and directing the call to a substitute function with identical parameters and return value. The use case is a unit test where the function under test uses a function during its execution, and this dependency is simulated by a substitute or double function during testing. The unit test is able to control the substitution of the dependency during run time, and thereby verify the behavior of the function under test.
	The following sample illustrates the relationship of the function under test and a dependency:		The following sample illustrates the relationship of the function under test and a dependency:

Line 41:		Line 41:

	The steps required to achieve doubling of a dependency function are as follows:		The steps required to achieve doubling of a dependency function are as follows:
	#[[#~~Configuring_the_Double_Using_SCL~~\|~~Configure~~ the Double ~~using SCL~~]]		#[[#Configuring the Double Using Function Pragma \| Configuring the Double Using Function Pragma]]
	#[[#Creating_Double_Intercepts_in_the_IM\|Create Double Intercepts in the IM]]		#[[#Creating_Double_Intercepts_in_the_IM\|Create Double Intercepts in the IM]]
	#[[#Switching_the_Double_Function_During_Runtime\|Switch Double Function During Runtime]]		#[[#Switching_the_Double_Function_During_Runtime\|Switch Double Function During Runtime]]


	==Configuring the Double Using ~~SCL~~==		==Configuring the Double Using Function Pragma==

	The syntax of the [[Scl_function\|scl_function]] pragma supports a set of '''''optional''''' attributes that allow the specification of function interception parameters.		The syntax of the [[Scl_function\|scl_function]] pragma supports a set of '''''optional''''' attributes that allow the specification of function interception parameters.

	In the above sample, ''depend()'' needs to be ~~SCL~~ captured and enabled for interception in a manner to be doubled.		In the above sample, ''depend()'' needs to be captured via the pragma and enabled for interception in a manner to be doubled.

	<source lang="c">		<source lang="c">
Line 61:		Line 61:

	==Creating Double Intercepts in the IM==		==Creating Double Intercepts in the IM==
	If a function has been configured as a double candidate using ~~SCL~~ as outlined in the above step, ~~then~~ the ~~next step is, using~~ [[Build_Tools\|STRIDE build tools]]~~, to~~ create the [[Intercept Module]], aka IM, that contains the intercept for the double function.		If a function has been configured as a double candidate using the function pragma as outlined in the above step, the [[Build_Tools\|STRIDE build tools]] will automatically create the [[Intercept Module]], aka IM, that contains the intercept for the double function. This all happens automatically during the build process.

	~~Once~~ the ~~IM has been successfully created,~~ the source file containing the <tt>depend()</tt> implementation must be altered to [[Name_Mangling\|mangle the function's name]] by defining the Group ID and including the generated Intercept Module header file (xxxIM.h):		But to enable the interception the source file containing the <tt>depend()</tt> implementation '''must be altered''' to [[Name_Mangling\|mangle the function's name]] by defining the Group ID and including the generated Intercept Module header file (xxxIM.h):

	<source lang="c">		<source lang="c">
Line 96:		Line 96:

	=== Example 1 ===		=== Example 1 ===
	The following example shows how to double a routine for the lifetime of a ~~[[Test_Units#C.2B.2B_Test_Classes\|~~C++ ~~test unit]]~~:		The following example shows how to double a routine for the lifetime of a C++ Test Unit:

	<source lang="cpp">		<source lang="cpp">

Marku at 22:16, 1 July 2015

2015-07-01T22:16:52Z

← Older revision		Revision as of 22:16, 1 July 2015
Line 148:		Line 148:
	}		}
	</source>		</source>

	~~[[Category:Test Units]]~~

Marku at 22:04, 1 July 2015

2015-07-01T22:04:44Z

← Older revision		Revision as of 22:04, 1 July 2015
Line 1:		Line 1:
	~~==Introduction==~~		__NOTOC__
	The ''Test Double'' feature provides a means for intercepting C/C++ language global functions on the target, and directing the call to a substitute function with identical parameters and return value. The use case is a unit test where the function under test uses a (global) function during its execution, and this dependency is simulated by a substitute or double function during testing. The unit test is able to control the substitution of the dependency during run time, and thereby verify the behavior of the function under test.		The ''Test Double'' feature provides a means for intercepting C/C++ language global functions on the target, and directing the call to a substitute function with identical parameters and return value. The use case is a unit test where the function under test uses a (global) function during its execution, and this dependency is simulated by a substitute or double function during testing. The unit test is able to control the substitution of the dependency during run time, and thereby verify the behavior of the function under test.
	The following sample illustrates the relationship of the function under test and a dependency:		The following sample illustrates the relationship of the function under test and a dependency:
Line 8:		Line 8:
	</source>		</source>


	<source lang="c">		<source lang="c">
	// depend.c		// depend.c
Line 17:		Line 18:
	}		}
	</source>		</source>


	<source lang="c">		<source lang="c">
Line 23:		Line 25:
	</source>		</source>


	<source lang="c">		<source lang="c">
	// test.c		// test.c
Line 33:		Line 36:
	}		}
	</source>		</source>


	In the above sample, ''test()'' is the function under test and ''depend()'' is a dependency candidate for doubling.		In the above sample, ''test()'' is the function under test and ''depend()'' is a dependency candidate for doubling.

			The steps required to achieve doubling of a dependency function are as follows:
			#[[#Configuring_the_Double_Using_SCL\|Configure the Double using SCL]]
			#[[#Creating_Double_Intercepts_in_the_IM\|Create Double Intercepts in the IM]]
			#[[#Switching_the_Double_Function_During_Runtime\|Switch Double Function During Runtime]]

	~~The steps required to achieve doubling of a dependency function are as follows:~~
	~~#[[#Configuring_the_Double_Using_SCL\|Configure the double parameters using SCL pragmas]]~~
	~~#[[#Creating_Double_Intercepts_in_the_IM\|Create the double intercepts in the IM]]~~
	~~#[[#Switching_the_Double_Function_During_Runtime\|Switch to/from the double function during runtime]]~~

	==Configuring the Double Using SCL==		==Configuring the Double Using SCL==
Line 54:		Line 58:
	#pragma scl_function(depend, "DEFINITION", "IMPLICIT", "TEST_GROUP")		#pragma scl_function(depend, "DEFINITION", "IMPLICIT", "TEST_GROUP")
	</source>		</source>


	==Creating Double Intercepts in the IM==		==Creating Double Intercepts in the IM==
Line 72:		Line 77:
	}		}
	</source>		</source>


	==Switching the Double Function During Runtime==		==Switching the Double Function During Runtime==

Marku: /* Switching the Double Function During Runtime */

2011-07-06T21:59:01Z

Switching the Double Function During Runtime

← Older revision		Revision as of 21:59, 6 July 2011
Line 80:		Line 80:
	srDOUBLE_RESET(fn)		srDOUBLE_RESET(fn)

	srDOUBLE_GET(fn, pfnDbl) // used for more advanced ~~use cases~~		srDOUBLE_GET(fn, pfnDbl) // used for more advanced scenarios
	</source>		</source>

Marku: /* Switching the Double Function During Runtime */

2011-07-06T21:12:44Z

Switching the Double Function During Runtime

← Older revision		Revision as of 21:12, 6 July 2011
Line 77:		Line 77:

	<source lang="c">		<source lang="c">
	~~srDOUBLE_GET(fn, pfnDbl)~~
	srDOUBLE_SET(fn, fnDbl)		srDOUBLE_SET(fn, fnDbl)
	srDOUBLE_RESET(fn)		srDOUBLE_RESET(fn)

			srDOUBLE_GET(fn, pfnDbl) // used for more advanced use cases
	</source>		</source>

Ivailop: /* Creating Double Intercepts in the IM */

2011-07-06T19:26:24Z

Creating Double Intercepts in the IM

← Older revision		Revision as of 19:26, 6 July 2011
Line 58:		Line 58:
	If a function has been configured as a double candidate using SCL as outlined in the above step, then the next step is, using [[Build_Tools\|STRIDE build tools]], to create the [[Intercept Module]], aka IM, that contains the intercept for the double function.		If a function has been configured as a double candidate using SCL as outlined in the above step, then the next step is, using [[Build_Tools\|STRIDE build tools]], to create the [[Intercept Module]], aka IM, that contains the intercept for the double function.

	Once the IM has been successfully created, the source file containing the <tt>depend()</tt> implementation must be altered to [[Name_Mangling\|mangle the ~~API~~'s name]] by defining the Group ID and including the generated Intercept Module header file (xxxIM.h):		Once the IM has been successfully created, the source file containing the <tt>depend()</tt> implementation must be altered to [[Name_Mangling\|mangle the function's name]] by defining the Group ID and including the generated Intercept Module header file (xxxIM.h):

	<source lang="c">		<source lang="c">

Ivailop: /* Example 2 */

2011-07-06T19:25:38Z

Example 2

← Older revision		Revision as of 19:25, 6 July 2011
Line 134:		Line 134:
	srFunctionDouble_t fn;		srFunctionDouble_t fn;
	srDOUBLE_GET(depend, &fn);		srDOUBLE_GET(depend, &fn);
	srDOUBLE_RESET(depend~~, &fn~~);		srDOUBLE_RESET(depend);
	ret = depend(a);		ret = depend(a);
	srDOUBLE_SET(depend, fn);		srDOUBLE_SET(depend, fn);