Symaptic: os/ossrv/lowlevellibsandfws/pluginfw/Framework/FrameTests/MagicUnitTests.h@260cb5ec6c19

     1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This file contains the definition of the

    15 // class CExampleInterfaceUnitTest

    16 //

    17 //

    19 #ifndef __MAGICUNITTEST_H__

    20 #define __MAGICUNITTEST_H__

    22 #include <e32base.h>

    24 #include <ecom/test_bed/unittest.h>

    25 #include "MagicStateAccessors.h"

    26 #include "MagicTransitions.h"

    27 #include "MagicTransitionValidation.h"

    29 // ______________________________________________________________________________

    30 //

    31 /**

    32 	@internalComponent

    33 	Comments : UnitTest CreateAndDestroy on the CExampleInterface test class.

    34  */

    35 class CExampleInterfaceCreateAndDestroyUnitTest : public CUnitTest

    36 	{

    37 public:

    38 	/**

    39 		@fn				NewL(CDataLogger& aDataLogger,

    40 							MUnitTestObserver& aObserver)

    41 		Intended Usage	: Standard two-phase construction which leaves nothing on the

    42 						cleanup stack.

    43 		Error Condition	: Leaves with the error code.

    44 		@leave			KErrNoMemory

    45 		@since			7.0

    46 		@param			aDataLogger The output logging object.

    47 		@param			aObserver The observer of this UnitTest.

    48 		@param			aStateAccessor WhiteBox state access to the CExampleInterface class.

    49 		@return			CExampleInterfaceCreateAndDestroyUnitTest* The constructed object.

    50 		@pre 			None.

    51 		@post			CExampleInterfaceCreateAndDestroyUnitTest is fully constructed, and initialised.

    52 	 */

    53 	static CExampleInterfaceCreateAndDestroyUnitTest* NewL(CDataLogger& aDataLogger,

    54 											MUnitTestObserver& aObserver);

    56 	/**

    57 		@fn				RunError(TInt aError)

    58 		Intended Usage	: Intercept the panic caused by a RunL leave,

    59 						to restore the CExampleInterfaceCreateAndDestroyUnitTest

    60 						object to a sensible state.

    61 						(called by the Active Scheduler immediately before the Panic).

    62 		Error Condition	: @see CUnitTest::RunError().

    63 		@since			7.0

    64 		@return			TInt KErrNone if cleanup successful, otherwise

    65 						@see CUnitTest::RunError()

    66 		@pre 			CExampleInterfaceCreateAndDestroyUnitTest is fully constructed, and initialised.

    67 		@post			The object has been restored to a sensible state.

    68 	 */

    69 	inline TInt RunError(TInt aError);

    71 	/**

    72 		@fn				~CExampleInterfaceCreateAndDestroyUnitTest()

    73 		Intended Usage	: Standard Destructor.

    74 		Error Condition	: None.

    75 		@since			7.0

    76 		@pre 			CExampleInterfaceCreateAndDestroyUnitTest is fully constructed.

    77 		@post			CExampleInterfaceCreateAndDestroyUnitTest is fully destroyed.

    78 	*/

    79 	inline ~CExampleInterfaceCreateAndDestroyUnitTest();

    81 private:

    82 	/**

    83 		@fn				CExampleInterfaceCreateAndDestroyUnitTest(CDataLogger& aDataLogger,

    84 														MUnitTestObserver& aObserver)

    85 		Intended Usage	: Default constructor.

    86 		Error Condition	: None.

    87 		@since			7.0

    88 		@param			aDataLogger The output logging object.

    89 		@param			aObserver The observer of this UnitTest.

    90 		@param			aStateAccessor WhiteBox state access to the CExampleInterface class.

    91 		@pre 			None.

    92 		@post			CExampleInterfaceCreateAndDestroyUnitTest is fully constructed.

    93 	*/

    94 	inline CExampleInterfaceCreateAndDestroyUnitTest(CDataLogger& aDataLogger,

    95 											MUnitTestObserver& aObserver);

    97 	/**

    98 		@fn				void ConstructL()

    99 		Intended Usage	: Second phase of safe two phase construction,

   100 		to complete the object initialisation.

   101 		Error Condition	: Leaves with an error code.

   102 		@leave  		KErrNoMemory, and @see CUnitTest::BaseNewL().

   103 		@since			7.0

   104 		@return			None

   105 		@pre 			CExampleInterfaceCreateAndDestroyUnitTest is fully constructed.

   106 		@post			CExampleInterfaceCreateAndDestroyUnitTest is fully initialised.

   107 	*/

   108 	inline void ConstructL();

   110 	/**

   111 	The context of the Unit Test.

   112 	i.e The CExampleInterface class tested by this UintTest's transitions.

   113 	 */

   114 	CExampleInterface_UnitTestContext*		iUTContext;

   115 	TExampleInterface_Ctor_TransitionValidator*		iCtorValidator;

   116 	TExampleInterface_Dtor_TransitionValidator*		iDtorValidator;

   117 	TExampleInterface_StateAccessor*	iStateAccessor;

   118 	REComSession* iEComSession;

   119 	};

   121 // ______________________________________________________________________________

   122 //

   123 /**

   124 	@internalComponent

   125 	Comments : UnitTest AltCreateAndDestroy on the CExampleInterface test class.

   126  */

   127 class CExampleInterfaceAltCreateAndDestroyUnitTest : public CUnitTest

   128 	{

   129 public:

   130 	/**

   131 		@fn				NewL(CDataLogger& aDataLogger,

   132 							MUnitTestObserver& aObserver)

   133 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   134 						cleanup stack.

   135 		Error Condition	: Leaves with the error code.

   136 		@leave			KErrNoMemory

   137 		@since			7.0

   138 		@param			aDataLogger The output logging object.

   139 		@param			aObserver The observer of this UnitTest.

   140 		@param			aStateAccessor WhiteBox state access to the CExampleInterface class.

   141 		@return			CExampleInterfaceAltCreateAndDestroyUnitTest* The constructed object.

   142 		@pre 			None.

   143 		@post			CExampleInterfaceAltCreateAndDestroyUnitTest is fully constructed, and initialised.

   144 	 */

   145 	static CExampleInterfaceAltCreateAndDestroyUnitTest* NewL(CDataLogger& aDataLogger,

   146 											MUnitTestObserver& aObserver);

   148 	/**

   149 		@fn				RunError(TInt aError)

   150 		Intended Usage	: Intercept the panic caused by a RunL leave,

   151 						to restore the CExampleInterfaceAltCreateAndDestroyUnitTest

   152 						object to a sensible state.

   153 						(called by the Active Scheduler immediately before the Panic).

   154 		Error Condition	: @see CUnitTest::RunError().

   155 		@since			7.0

   156 		@return			TInt KErrNone if cleanup successful, otherwise

   157 						@see CUnitTest::RunError()

   158 		@pre 			CExampleInterfaceAltCreateAndDestroyUnitTest is fully constructed, and initialised.

   159 		@post			The object has been restored to a sensible state.

   160 	 */

   161 	inline TInt RunError(TInt aError);

   163 	/**

   164 		@fn				~CExampleInterfaceAltCreateAndDestroyUnitTest()

   165 		Intended Usage	: Standard Destructor.

   166 		Error Condition	: None.

   167 		@since			7.0

   168 		@pre 			CExampleInterfaceAltCreateAndDestroyUnitTest is fully constructed.

   169 		@post			CExampleInterfaceAltCreateAndDestroyUnitTest is fully destroyed.

   170 	*/

   171 	inline ~CExampleInterfaceAltCreateAndDestroyUnitTest();

   173 private:

   174 	/**

   175 		@fn				CExampleInterfaceAltCreateAndDestroyUnitTest(CDataLogger& aDataLogger,

   176 														MUnitTestObserver& aObserver)

   177 		Intended Usage	: Default constructor.

   178 		Error Condition	: None.

   179 		@since			7.0

   180 		@param			aDataLogger The output logging object.

   181 		@param			aObserver The observer of this UnitTest.

   182 		@param			aStateAccessor WhiteBox state access to the CExampleInterface class.

   183 		@pre 			None.

   184 		@post			CExampleInterfaceAltCreateAndDestroyUnitTest is fully constructed.

   185 	*/

   186 	inline CExampleInterfaceAltCreateAndDestroyUnitTest(CDataLogger& aDataLogger,

   187 											MUnitTestObserver& aObserver);

   189 	/**

   190 		@fn				void ConstructL()

   191 		Intended Usage	: Second phase of safe two phase construction,

   192 		to complete the object initialisation.

   193 		Error Condition	: Leaves with an error code.

   194 		@leave  		KErrNoMemory, and @see CUnitTest::BaseNewL().

   195 		@since			7.0

   196 		@return			None

   197 		@pre 			CExampleInterfaceAltCreateAndDestroyUnitTest is fully constructed.

   198 		@post			CExampleInterfaceAltCreateAndDestroyUnitTest is fully initialised.

   199 	*/

   200 	inline void ConstructL();

   202 	/**

   203 	The context of the Unit Test.

   204 	i.e The CExampleInterface class tested by this UnitTest's transitions.

   205 	 */

   206 	CExampleInterface_UnitTestContext*		iUTContext;

   207 	TExampleInterface_Ctor_TransitionValidator*		iCtorValidator;

   208 	TExampleInterface_Dtor_TransitionValidator*		iDtorValidator;

   209 	TExampleInterface_StateAccessor*	iStateAccessor;

   210 	REComSession* iEComSession;

   211 	};

   214 // ______________________________________________________________________________

   215 //

   216 /**

   217 	@internalComponent

   218 	Comments : Unit Test for the ListI mplementations functions on CExampleInterface,

   219 	the class under test.

   220  */

   221 class CExampleInterface_ListImplementations_UnitTest : public CUnitTest

   222 	{

   223 public:

   224 	/**

   225 		@fn				NewL(CDataLogger& aDataLogger,

   226 							MUnitTestObserver& aObserver)

   227 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   228 						cleanup stack.

   229 		Error Condition	: Leaves with the error code.

   230 		@leave  		KErrNoMemory

   231 		@since			7.0

   232 		@param			aDataLogger The output logging object.

   233 		@param			aObserver The observer of this UnitTest.

   234 		@return			CExampleInterface_ListImplementations_UnitTest* The constructed

   235 						object.

   236 		@pre 			None.

   237 		@post			CExampleInterface_ListImplementations_UnitTest is fully

   238 						constructed, and initialised.

   239 	 */

   240 	static CExampleInterface_ListImplementations_UnitTest* NewL(CDataLogger& aDataLogger,

   241 											MUnitTestObserver& aObserver);

   243 	/**

   244 		@fn				RunError(TInt aError)

   245 		Intended Usage	: Intercept the panic caused by a RunL leave,

   246 						to restore the CExampleInterface_ListImplementations_UnitTest

   247 						object to a sensible state.

   248 						(called by the Active Scheduler immediately before the Panic).

   249 		Error Condition	: @see CUnitTest::RunError().

   250 		@since			7.0

   251 		@return			TInt KErrNone if cleanup successful, otherwise

   252 						@see CUnitTest::RunError()

   253 		@pre 			CExampleInterface_ListImplementations_UnitTest is fully

   254 						constructed, and initialised.

   255 		@post			The object has been restored to a sensible state.

   256 	 */

   257 	inline TInt RunError(TInt aError);

   259 	/**

   260 		@fn				~CExampleInterface_ListImplementations_UnitTest()

   261 		Intended Usage	: Standard Destructor.

   262 		Error Condition	: None.

   263 		@since			7.0

   264 		@pre 			CExampleInterface_ListImplementations_UnitTest is

   265 						fully constructed.

   266 		@post			CExampleInterface_ListImplementations_UnitTest is

   267 						fully destroyed.

   268 	*/

   269 	~CExampleInterface_ListImplementations_UnitTest();

   271 private:

   272 	/**

   273 		@fn				CExampleInterface_ListImplementations_UnitTest(CDataLogger& aDataLogger,

   274 														MUnitTestObserver& aObserver)

   275 		Intended Usage	: Default constructor.

   276 		Error Condition	: None.

   277 		@since			7.0

   278 		@param			aDataLogger The output logging object.

   279 		@param			aObserver The observer of this UnitTest.

   280 		@param			aStateAccessor WhiteBox state access to the CExampleInterface class.

   281 		@pre 			None.

   282 		@post			CExampleInterface_ListImplementations_UnitTest is fully

   283 						constructed.

   284 	*/

   285 	inline CExampleInterface_ListImplementations_UnitTest(CDataLogger& aDataLogger,

   286 											MUnitTestObserver& aObserver);

   288 	/**

   289 		@fn				void ConstructL()

   290 		Intended Usage	: Second phase of safe two phase construction,

   291 		to complete the object initialisation.

   292 		Error Condition	: Leaves with an error code.

   293 		@leave  		KErrNoMemory, and @see CUnitTest::BaseNewL().

   294 		@since			7.0

   295 		@return			None

   296 		@pre 			CExampleInterface_ListImplementations_UnitTest is

   297 						fully constructed.

   298 		@post			CExampleInterface_ListImplementations_UnitTest is

   299 						fully initialised.

   300 	*/

   301 	void ConstructL();

   303 	/**

   304 	The context of the Unit Test.

   305 	i.e The CExampleInterface class tested by this UnitTest's transitions.

   306 	 */

   307 	CExampleInterface_UnitTestContext* iUTContext;

   308 	TExampleInterface_StateAccessor*	iStateAccessor;

   309 	// C'tor, d'tor, and method transition validators

   310 	TExampleInterface_Ctor_TransitionValidator*	iCtorValidator;

   311 	TExampleInterface_ListImplementations_TransitionValidator*	iListImplementationsValidator;

   312 	TExampleInterface_Dtor_TransitionValidator*	iDtorValidator;

   313 	REComSession* iEComSession;

   314 	};	// CExampleInterface_ListImplementations_UnitTest

   316 // ______________________________________________________________________________

   317 //

   318 /**

   319 	@internalComponent

   320 	Comments : Unit Test for DefectHAN4WZHSY on CExampleInterface, the class under test.

   321  */

   322 class CExampleInterface_DefectHAN4WZHSY_UnitTest : public CUnitTest

   323 	{

   324 public:

   325 	/**

   326 		@fn				NewL(CDataLogger& aDataLogger,

   327 							MUnitTestObserver& aObserver)

   328 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   329 						cleanup stack.

   330 		Error Condition	: Leaves with the error code.

   331 		@leave  		KErrNoMemory

   332 		@since			7.0

   333 		@param			aDataLogger The output logging object.

   334 		@param			aObserver The observer of this UnitTest.

   335 		@return			CExampleInterface_DefectHAN4WZHSY_UnitTest* The constructed object.

   336 		@pre 			None.

   337 		@post			CExampleInterface_DefectHAN4WZHSY_UnitTest is fully constructed, and initialised.

   338 	 */

   339 	static CExampleInterface_DefectHAN4WZHSY_UnitTest* NewL(CDataLogger& aDataLogger,

   340 											MUnitTestObserver& aObserver);

   342 	/**

   343 		@fn				RunError(TInt aError)

   344 		Intended Usage	: Intercept the panic caused by a RunL leave,

   345 						to restore the CExampleInterface_DefectHAN4WZHSY_UnitTest

   346 						object to a sensible state.

   347 						(called by the Active Scheduler immediately before the Panic).

   348 		Error Condition	: @see CUnitTest::RunError().

   349 		@since			7.0

   350 		@return			TInt KErrNone if cleanup successful, otherwise

   351 						@see CUnitTest::RunError()

   352 		@pre 			CExampleInterface_DefectHAN4WZHSY_UnitTest is fully constructed, and initialised.

   353 		@post			The object has been restored to a sensible state.

   354 	 */

   355 	inline TInt RunError(TInt aError);

   357 	/**

   358 		@fn				~CExampleInterface_DefectHAN4WZHSY_UnitTest()

   359 		Intended Usage	: Standard Destructor.

   360 		Error Condition	: None.

   361 		@since			7.0

   362 		@pre 			CExampleInterface_DefectHAN4WZHSY_UnitTest is fully constructed.

   363 		@post			CExampleInterface_DefectHAN4WZHSY_UnitTest is fully destroyed.

   364 	*/

   365 	~CExampleInterface_DefectHAN4WZHSY_UnitTest();

   367 private:

   368 	/**

   369 		@fn				CExampleInterface_DefectHAN4WZHSY_UnitTest(CDataLogger& aDataLogger,

   370 														MUnitTestObserver& aObserver)

   371 		Intended Usage	: Default constructor.

   372 		Error Condition	: None.

   373 		@since			7.0

   374 		@param			aDataLogger The output logging object.

   375 		@param			aObserver The observer of this UnitTest.

   376 		@param			aStateAccessor WhiteBox state access to the CExampleInterface class.

   377 		@pre 			None.

   378 		@post			CExampleInterface_DefectHAN4WZHSY_UnitTest is fully constructed.

   379 	*/

   380 	inline CExampleInterface_DefectHAN4WZHSY_UnitTest(CDataLogger& aDataLogger,

   381 											MUnitTestObserver& aObserver);

   383 	/**

   384 		@fn				void ConstructL()

   385 		Intended Usage	: Second phase of safe two phase construction,

   386 		to complete the object initialisation.

   387 		Error Condition	: Leaves with an error code.

   388 		@leave  		KErrNoMemory, and @see CUnitTest::BaseNewL().

   389 		@since			7.0

   390 		@return			None

   391 		@pre 			CExampleInterface_DefectHAN4WZHSY_UnitTest is fully constructed.

   392 		@post			CExampleInterface_DefectHAN4WZHSY_UnitTest is fully initialised.

   393 	*/

   394 	void ConstructL();

   396 	/**

   397 	The context of the Unit Test.

   398 	i.e The CExampleInterface class tested by this UnitTest's transitions.

   399 	 */

   400 	CExampleInterface_UnitTestContext* iUTContext;

   401 	TExampleInterface_StateAccessor*	iStateAccessor;

   403 	// C'tor, d'tor, and method transition validators

   404 	TExampleInterface_Ctor_TransitionValidator*	iCtorValidator;

   405 	TExampleInterface_Dtor_TransitionValidator*	iDtorValidator;

   406 	};	// CExampleInterface_DefectHAN4WZHSY_UnitTest

   408 // ______________________________________________________________________________

   409 //

   410 /**

   411 	@internalComponent

   412 	Comments : Unit Test for DefectCUO4YCEUE on CExampleInterface, the class under test.

   413  */

   414 class CExampleInterface_DefectCUO4YCEUE_UnitTest : public CUnitTest

   415 	{

   416 public:

   417 	/**

   418 		@fn				NewL(CDataLogger& aDataLogger,

   419 							MUnitTestObserver& aObserver)

   420 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   421 						cleanup stack.

   422 		Error Condition	: Leaves with the error code.

   423 		@leave  		KErrNoMemory

   424 		@since			7.0

   425 		@param			aDataLogger The output logging object.

   426 		@param			aObserver The observer of this UnitTest.

   427 		@return			CExampleInterface_DefectCUO4YCEUE_UnitTest* The constructed object.

   428 		@pre 			None.

   429 		@post			CExampleInterface_DefectCUO4YCEUE_UnitTest is fully constructed, and initialised.

   430 	 */

   431 	static CExampleInterface_DefectCUO4YCEUE_UnitTest* NewL(CDataLogger& aDataLogger,

   432 											MUnitTestObserver& aObserver);

   434 	/**

   435 		@fn				RunError(TInt aError)

   436 		Intended Usage	: Intercept the panic caused by a RunL leave,

   437 						to restore the CExampleInterface_DefectHAN4WZHSY_UnitTest

   438 						object to a sensible state.

   439 						(called by the Active Scheduler immediately before the Panic).

   440 		Error Condition	: @see CUnitTest::RunError().

   441 		@since			7.0

   442 		@return			TInt KErrNone if cleanup successful, otherwise

   443 						@see CUnitTest::RunError()

   444 		@pre 			CExampleInterface_DefectCUO4YCEUE_UnitTest is fully constructed, and initialised.

   445 		@post			The object has been restored to a sensible state.

   446 	 */

   447 	inline TInt RunError(TInt aError);

   449 	/**

   450 		@fn				~CExampleInterface_DefectCUO4YCEUE_UnitTest()

   451 		Intended Usage	: Standard Destructor.

   452 		Error Condition	: None.

   453 		@since			7.0

   454 		@pre 			CExampleInterface_DefectCUO4YCEUE_UnitTest is fully constructed.

   455 		@post			CExampleInterface_DefectCUO4YCEUE_UnitTest is fully destroyed.

   456 	*/

   457 	~CExampleInterface_DefectCUO4YCEUE_UnitTest();

   459 private:

   460 	/**

   461 		@fn				CExampleInterface_DefectCUO4YCEUE_UnitTest(CDataLogger& aDataLogger,

   462 														MUnitTestObserver& aObserver)

   463 		Intended Usage	: Default constructor.

   464 		Error Condition	: None.

   465 		@since			7.0

   466 		@param			aDataLogger The output logging object.

   467 		@param			aObserver The observer of this UnitTest.

   468 		@param			aStateAccessor WhiteBox state access to the CExampleInterface class.

   469 		@pre 			None.

   470 		@post			CExampleInterface_DefectCUO4YCEUE_UnitTest is fully constructed.

   471 	*/

   472 	inline CExampleInterface_DefectCUO4YCEUE_UnitTest(CDataLogger& aDataLogger,

   473 											MUnitTestObserver& aObserver);

   475 	/**

   476 		@fn				void ConstructL()

   477 		Intended Usage	: Second phase of safe two phase construction,

   478 		to complete the object initialisation.

   479 		Error Condition	: Leaves with an error code.

   480 		@leave  		KErrNoMemory, and @see CUnitTest::BaseNewL().

   481 		@since			7.0

   482 		@return			None

   483 		@pre 			CExampleInterface_DefectCUO4YCEUE_UnitTest is fully constructed.

   484 		@post			CExampleInterface_DefectCUO4YCEUE_UnitTest is fully initialised.

   485 	*/

   486 	void ConstructL();

   488 	/**

   489 	The context of the Unit Test.

   490 	i.e The CExampleInterface class tested by this UnitTest's transitions.

   491 	 */

   492 	CExampleInterface_UnitTestContext* iUTContext;

   493 	TExampleInterface_StateAccessor*	iStateAccessor;

   495 	// C'tor, d'tor, and method transition validators

   496 	TExampleInterface_Ctor_TransitionValidator*	iCtorValidator;

   497 	TExampleInterface_Dtor_TransitionValidator*	iDtorValidator;

   498 	};	// CExampleInterface_DefectCUO4YCEUE_UnitTest

   500 // ______________________________________________________________________________

   501 //

   502 /**

   503 	@internalComponent

   504 	Comments : Unit Test for DefectEVS-4Z9BPG on CExampleInterface, the class under test.

   505  */

   506 class CExampleInterface_DefectEVS4Z9BPG_UnitTest : public CUnitTest

   507 	{

   508 public:

   509 	/**

   510 		@fn				NewL(CDataLogger& aDataLogger,

   511 							MUnitTestObserver& aObserver)

   512 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   513 						cleanup stack.

   514 		Error Condition	: Leaves with the error code.

   515 		@leave  		KErrNoMemory

   516 		@since			7.0

   517 		@param			aDataLogger The output logging object.

   518 		@param			aObserver The observer of this UnitTest.

   519 		@return			CExampleInterface_DefectEVS4Z9BPG_UnitTest* The constructed object.

   520 		@pre 			None.

   521 		@post			CExampleInterface_DefectEVS4Z9BPG_UnitTest is fully constructed, and initialised.

   522 	 */

   523 	static CExampleInterface_DefectEVS4Z9BPG_UnitTest* NewL(CDataLogger& aDataLogger,

   524 											MUnitTestObserver& aObserver);

   526 	/**

   527 		@fn				RunError(TInt aError)

   528 		Intended Usage	: Intercept the panic caused by a RunL leave,

   529 						to restore the CExampleInterface_DefectHAN4WZHSY_UnitTest

   530 						object to a sensible state.

   531 						(called by the Active Scheduler immediately before the Panic).

   532 		Error Condition	: @see CUnitTest::RunError().

   533 		@since			7.0

   534 		@return			TInt KErrNone if cleanup successful, otherwise

   535 						@see CUnitTest::RunError()

   536 		@pre 			CExampleInterface_DefectEVS4Z9BPG_UnitTest is fully constructed, and initialised.

   537 		@post			The object has been restored to a sensible state.

   538 	 */

   539 	inline TInt RunError(TInt aError);

   541 	/**

   542 		@fn				~CExampleInterface_DefectEVS4Z9BPG_UnitTest()

   543 		Intended Usage	: Standard Destructor.

   544 		Error Condition	: None.

   545 		@since			7.0

   546 		@pre 			CExampleInterface_DefectEVS4Z9BPG_UnitTest is fully constructed.

   547 		@post			CExampleInterface_DefectEVS4Z9BPG_UnitTest is fully destroyed.

   548 	*/

   549 	~CExampleInterface_DefectEVS4Z9BPG_UnitTest();

   551 private:

   552 	/**

   553 		@fn				CExampleInterface_DefectEVS4Z9BPG_UnitTest(CDataLogger& aDataLogger,

   554 														MUnitTestObserver& aObserver)

   555 		Intended Usage	: Default constructor.

   556 		Error Condition	: None.

   557 		@since			7.0

   558 		@param			aDataLogger The output logging object.

   559 		@param			aObserver The observer of this UnitTest.

   560 		@param			aStateAccessor WhiteBox state access to the CExampleInterface class.

   561 		@pre 			None.

   562 		@post			CExampleInterface_DefectEVS4Z9BPG_UnitTest is fully constructed.

   563 	*/

   564 	inline CExampleInterface_DefectEVS4Z9BPG_UnitTest(CDataLogger& aDataLogger,

   565 											MUnitTestObserver& aObserver);

   567 	/**

   568 		@fn				void ConstructL()

   569 		Intended Usage	: Second phase of safe two phase construction,

   570 		to complete the object initialisation.

   571 		Error Condition	: Leaves with an error code.

   572 		@leave  		KErrNoMemory, and @see CUnitTest::BaseNewL().

   573 		@since			7.0

   574 		@return			None

   575 		@pre 			CExampleInterface_DefectEVS4Z9BPG_UnitTest is fully constructed.

   576 		@post			CExampleInterface_DefectEVS4Z9BPG_UnitTest is fully initialised.

   577 	*/

   578 	void ConstructL();

   580 	/**

   581 	The context of the Unit Test.

   582 	i.e The CExampleInterface class tested by this UnitTest's transitions.

   583 	 */

   584 	CExampleInterface_UnitTestContext* iUTContext;

   585 	TExampleInterface_StateAccessor*	iStateAccessor;

   587 	// C'tor, d'tor, and method transition validators

   588 	TExampleInterface_Ctor_TransitionValidator*	iCtorValidator;

   589 	TExampleInterface_Default_TransitionValidator*	iDefaultValidator;

   590 	TExampleInterface_Dtor_TransitionValidator*	iDtorValidator;

   591 	};	// CExampleInterface_DefectEVS4Z9BPG_UnitTest

   593 // ______________________________________________________________________________

   594 //

   595 /**

   596 	@internalComponent

   597 	Comments : Unit Test for DefectKRN-53SL4Q on CExampleInterface, the class under test.

   598  */

   599 class CExampleInterface_DefectKRN53SL4Q_UnitTest : public CUnitTest

   600 	{

   601 public:

   602 	/**

   603 		@fn				NewL(CDataLogger& aDataLogger,

   604 							MUnitTestObserver& aObserver)

   605 		Intended Usage	: Standard two-phase construction which leaves nothing on the

   606 						cleanup stack.

   607 		Error Condition	: Leaves with the error code.

   608 		@leave  		KErrNoMemory

   609 		@since			7.0

   610 		@param			aDataLogger The output logging object.

   611 		@param			aObserver The observer of this UnitTest.

   612 		@return			CExampleInterface_DefectKRN53SL4Q_UnitTest* The constructed object.

   613 		@pre 			None.

   614 		@post			CExampleInterface_DefectKRN53SL4Q_UnitTest is fully constructed, and initialised.

   615 	 */

   616 	static CExampleInterface_DefectKRN53SL4Q_UnitTest* NewL(CDataLogger& aDataLogger,

   617 											MUnitTestObserver& aObserver);

   619 	/**

   620 		@fn				RunError(TInt aError)

   621 		Intended Usage	: Intercept the panic caused by a RunL leave,

   622 						to restore the CExampleInterface_DefectKRN53SL4Q_UnitTest

   623 						object to a sensible state.

   624 						(called by the Active Scheduler immediately before the Panic).

   625 		Error Condition	: @see CUnitTest::RunError().

   626 		@since			7.0

   627 		@return			TInt KErrNone if cleanup successful, otherwise

   628 						@see CUnitTest::RunError()

   629 		@pre 			CExampleInterface_DefectKRN53SL4Q_UnitTest is fully constructed, and initialised.

   630 		@post			The object has been restored to a sensible state.

   631 	 */

   632 	inline TInt RunError(TInt aError);

   634 	/**

   635 		@fn				~CExampleInterface_DefectKRN53SL4Q_UnitTest()

   636 		Intended Usage	: Standard Destructor.

   637 		Error Condition	: None.

   638 		@since			7.0

   639 		@pre 			CExampleInterface_DefectKRN53SL4Q_UnitTest is fully constructed.

   640 		@post			CExampleInterface_DefectKRN53SL4Q_UnitTest is fully destroyed.

   641 	*/

   642 	~CExampleInterface_DefectKRN53SL4Q_UnitTest();

   644 private:

   645 	/**

   646 		@fn				CExampleInterface_DefectKRN53SL4Q_UnitTest(CDataLogger& aDataLogger,

   647 														MUnitTestObserver& aObserver)

   648 		Intended Usage	: Default constructor.

   649 		Error Condition	: None.

   650 		@since			7.0

   651 		@param			aDataLogger The output logging object.

   652 		@param			aObserver The observer of this UnitTest.

   653 		@param			aStateAccessor WhiteBox state access to the CExampleInterface class.

   654 		@pre 			None.

   655 		@post			CExampleInterface_DefectKRN53SL4Q_UnitTest is fully constructed.

   656 	*/

   657 	inline CExampleInterface_DefectKRN53SL4Q_UnitTest(CDataLogger& aDataLogger,

   658 											MUnitTestObserver& aObserver);

   660 	/**

   661 		@fn				void ConstructL()

   662 		Intended Usage	: Second phase of safe two phase construction,

   663 		to complete the object initialisation.

   664 		Error Condition	: Leaves with an error code.

   665 		@leave  		KErrNoMemory, and @see CUnitTest::BaseNewL().

   666 		@since			7.0

   667 		@return			None

   668 		@pre 			CExampleInterface_DefectKRN53SL4Q_UnitTest is fully constructed.

   669 		@post			CExampleInterface_DefectKRN53SL4Q_UnitTest is fully initialised.

   670 	*/

   671 	void ConstructL();

   673 	/**

   674 	The context of the Unit Test.

   675 	i.e The CExampleInterface class tested by this UnitTest's transitions.

   676 	 */

   677 	CExampleInterface_UnitTestContext* iUTContext;

   678 	TExampleInterface_StateAccessor*	iStateAccessor;

   680 	// C'tor, d'tor, and method transition validators

   681 	TExampleInterface_Ctor_TransitionValidator*	iCtorValidator;

   682 	TExampleInterface_Default_TransitionValidator*	iDefaultValidator;

   683 	TExampleInterface_Dtor_TransitionValidator*	iDtorValidator;

   684 	};	// CExampleInterface_DefectKRN53SL4Q_UnitTest

   686 #endif

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--