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 // The definition of the unit tests for the CRegistrar class

    15 // 

    16 //

    17 

    18 #ifndef __REGISTRARUNITTESTS_H__

    19 #define __REGISTRARUNITTESTS_H__

    20 

    21 #include "RegistrarTransitionValidation.h"

    22 #include "RegistrarObserver.h"

    23 

    24 // ______________________________________________________________________________

    25 //

    26 /**

    27 	@internalComponent

    28 	Comments : Unit Test for CreateAndDestroy on CRegistrar, the class under test.

    29  */

    30 class CRegistrar_CreateAndDestroy_UnitTest : public CUnitTest, private MRegistrarObserver

    31 	{

    32 public:

    33 	/**

    34 		@fn				NewL(CDataLogger& aDataLogger,

    35 							MUnitTestObserver& aObserver)

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

    37 						cleanup stack.

    38 		Error Condition	: Leaves with the error code.

    39 		@leave  		KErrNoMemory

    40 		@since			7.0

    41 		@param			aDataLogger The output logging object.

    42 		@param			aObserver The observer of this UnitTest.

    43 		@return			CRegistrar_CreateAndDestroy_UnitTest* The constructed object.

    44 		@pre 			None.

    45 		@post			CRegistrar_CreateAndDestroy_UnitTest is fully constructed, and initialised.

    46 	 */

    47 	static CRegistrar_CreateAndDestroy_UnitTest* NewL(CDataLogger& aDataLogger,

    48 											MUnitTestObserver& aObserver);

    49 

    50 	/**

    51 		@fn				RunError(TInt aError)

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

    53 						to restore the CRegistrar_CreateAndDestroy_UnitTest

    54 						object to a sensible state.

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

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

    57 		@since			7.0

    58 		@return			TInt KErrNone if cleanup successful, otherwise

    59 						@see CUnitTest::RunError()

    60 		@pre 			CRegistrar_CreateAndDestroy_UnitTest is fully constructed, and initialised.

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

    62 	 */

    63 	inline TInt RunError(TInt aError);

    64 

    65 	/**

    66 		@fn				~CRegistrar_CreateAndDestroy_UnitTest()

    67 		Intended Usage	: Standard Destructor.

    68 		Error Condition	: None.	

    69 		@since			7.0

    70 		@pre 			CRegistrar_CreateAndDestroy_UnitTest is fully constructed.

    71 		@post			CRegistrar_CreateAndDestroy_UnitTest is fully destroyed.

    72 	*/

    73 	~CRegistrar_CreateAndDestroy_UnitTest();

    74 

    75 /**

    76 	@fn				PrepareUnitTestL()

    77 	Intended Usage	: Called by test framework just before test is run to allow

    78 					any test preparation to take place.

    79 	Error Condition	: 

    80 	@since			7.0

    81 	@pre 			CRegistrar_CreateAndDestroy_UnitTest is fully constructed.

    82 	@post			This unit test is ready to run.

    83 */

    84 	void PrepareUnitTestL();

    85 

    86 private:

    87 	/**

    88 		@fn				CRegistrar_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

    89 														MUnitTestObserver& aObserver)

    90 		Intended Usage	: Default constructor.

    91 		Error Condition	: None. 

    92 		@since			7.0

    93 		@param			aDataLogger The output logging object.

    94 		@param			aObserver The observer of this UnitTest.

    95 		@param			aStateAccessor WhiteBox state access to the CRegistrar class.

    96 		@pre 			None.

    97 		@post			CRegistrar_CreateAndDestroy_UnitTest is fully constructed.

    98 	*/

    99 	inline CRegistrar_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

   100 											MUnitTestObserver& aObserver);

   101 

   102 	/**

   103 		@fn				void ConstructL()

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

   105 		to complete the object initialisation.

   106 		Error Condition	: Leaves with an error code.

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

   108 		@since			7.0

   109 		@return			None 

   110 		@pre 			CRegistrar_CreateAndDestroy_UnitTest is fully constructed.

   111 		@post			CRegistrar_CreateAndDestroy_UnitTest is fully initialised.

   112 	*/

   113 	void ConstructL();

   114 

   115 	void Notification(TInt aNotificationCode);

   116 

   117 	/**

   118 	The context of the Unit Test.

   119 	i.e The CRegistrar class tested by this UnitTest's transitions.

   120 	 */

   121 	CRegistrar_UnitTestContext* iUTContext;

   122 	TRegistrar_StateAccessor*	iStateAccessor;

   123 

   124 /** Registry data which is required for constructing a CRegistrar */

   125 	CRegistryData*	iRegistryData;

   126 

   127 /** C'tor transition validator */

   128 	TRegistrar_Ctor_TransitionValidator*	iCtorValidator;

   129 /** D'tor transition validator */

   130 	TRegistrar_Dtor_TransitionValidator*	iDtorValidator;

   131 	};	// CRegistrar_CreateAndDestroy_UnitTest

   132 

   133 // ______________________________________________________________________________

   134 //

   135 /**

   136 	@internalComponent	

   137 	Comments : Unit Test for BeginComplete on CRegistrar, the class under test.

   138  */

   139 class CRegistrar_BeginComplete_UnitTest : public CUnitTest, private MRegistrarObserver

   140 	{

   141 public:

   142 	/**

   143 		@fn				NewL(CDataLogger& aDataLogger,

   144 							MUnitTestObserver& aObserver)

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

   146 						cleanup stack.

   147 		Error Condition	: Leaves with the error code.

   148 		@leave			KErrNoMemory

   149 		@since			7.0

   150 		@param			aDataLogger The output logging object.

   151 		@param			aObserver The observer of this UnitTest.

   152 		@return			CRegistrar_BeginComplete_UnitTest* The constructed object.

   153 		@pre 			None.

   154 		@post			CRegistrar_BeginComplete_UnitTest is fully constructed, and initialised.

   155 	 */

   156 	static CRegistrar_BeginComplete_UnitTest* NewL(CDataLogger& aDataLogger,

   157 											MUnitTestObserver& aObserver);

   158 

   159 	/**

   160 		@fn				RunError(TInt aError)

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

   162 						to restore the CRegistrar_BeginComplete_UnitTest

   163 						object to a sensible state.

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

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

   166 		@since			7.0

   167 		@return			TInt KErrNone if cleanup successful, otherwise

   168 						@see CUnitTest::RunError()

   169 		@pre 			CRegistrar_BeginComplete_UnitTest is fully constructed, and initialised.

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

   171 	 */

   172 	inline TInt RunError(TInt aError);

   173 

   174 	/**

   175 		@fn				~CRegistrar_BeginComplete_UnitTest()

   176 		Intended Usage	: Standard Destructor.

   177 		Error Condition	: None.	

   178 		@since			7.0

   179 		@pre 			CRegistrar_BeginComplete_UnitTest is fully constructed.

   180 		@post			CRegistrar_BeginComplete_UnitTest is fully destroyed.

   181 	*/

   182 	~CRegistrar_BeginComplete_UnitTest();

   183 

   184 private:

   185 	/**

   186 		@fn				CRegistrar_BeginComplete_UnitTest(CDataLogger& aDataLogger,

   187 														MUnitTestObserver& aObserver)

   188 		Intended Usage	: Default constructor.

   189 		Error Condition	: None. 

   190 		@since			7.0

   191 		@param			aDataLogger The output logging object.

   192 		@param			aObserver The observer of this UnitTest.

   193 		@param			aStateAccessor WhiteBox state access to the CRegistrar class.

   194 		@pre 			None.

   195 		@post			CRegistrar_BeginComplete_UnitTest is fully constructed.

   196 	*/

   197 	inline CRegistrar_BeginComplete_UnitTest(CDataLogger& aDataLogger,

   198 											MUnitTestObserver& aObserver);

   199 

   200 	/**

   201 		@fn				void ConstructL()

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

   203 		to complete the object initialisation.

   204 		Error Condition	: Leaves with an error code.

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

   206 		@since			7.0

   207 		@return			None 

   208 		@pre 			CRegistrar_BeginComplete_UnitTest is fully constructed.

   209 		@post			CRegistrar_BeginComplete_UnitTest is fully initialised.

   210 	*/

   211 	void ConstructL();

   212 

   213 	void Notification(TInt aNotificationCode);

   214 

   215 	/**

   216 	The context of the Unit Test.

   217 	i.e The CRegistrar class tested by this UnitTest's transitions.

   218 	 */

   219 	CRegistrar_UnitTestContext* iUTContext;

   220 	TRegistrar_StateAccessor*	iStateAccessor;

   221 

   222 /** Registry data which is required for constructing a CRegistrar */

   223 	CRegistryData*	iRegistryData;

   224 

   225 	// C'tor, d'tor, and default transition validators

   226 	TRegistrar_Ctor_TransitionValidator*	iCtorValidator;

   227 	TRegistrar_Default_TransitionValidator*	iDefaultValidator;

   228 	TRegistrar_Dtor_TransitionValidator*	iDtorValidator;

   229 	};	// CRegistrar_BeginComplete_UnitTest

   230 

   231 // ______________________________________________________________________________

   232 //

   233 /**

   234 	@internalComponent

   235 	Comments : Unit Test for RegisterDiscovery on CRegistrar, the class under test.

   236  */

   237 class CRegistrar_RegisterDiscovery_UnitTest : public CUnitTest, private MRegistrarObserver

   238 	{

   239 public:

   240 	/**

   241 		@fn				NewL(CDataLogger& aDataLogger,

   242 							MUnitTestObserver& aObserver)

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

   244 						cleanup stack.

   245 		Error Condition	: Leaves with the error code.

   246 		@leave  		KErrNoMemory

   247 		@since			7.0

   248 		@param			aDataLogger The output logging object.

   249 		@param			aObserver The observer of this UnitTest.

   250 		@return			CRegistrar_RegisterDiscovery_UnitTest* The constructed object.

   251 		@pre 			None.

   252 		@post			CRegistrar_RegisterDiscovery_UnitTest is fully constructed, and initialised.

   253 	 */

   254 	static CRegistrar_RegisterDiscovery_UnitTest* NewL(CDataLogger& aDataLogger,

   255 											MUnitTestObserver& aObserver);

   256 

   257 	/**

   258 		@fn				RunError(TInt aError)

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

   260 						to restore the CRegistrar_RegisterDiscovery_UnitTest

   261 						object to a sensible state.

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

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

   264 		@since			7.0

   265 		@return			TInt KErrNone if cleanup successful, otherwise

   266 						@see CUnitTest::RunError()

   267 		@pre 			CRegistrar_RegisterDiscovery_UnitTest is fully constructed, and initialised.

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

   269 	 */

   270 	inline TInt RunError(TInt aError);

   271 

   272 	/**

   273 		@fn				~CRegistrar_RegisterDiscovery_UnitTest()

   274 		Intended Usage	: Standard Destructor.

   275 		Error Condition	: None.	

   276 		@since			7.0

   277 		@pre 			CRegistrar_RegisterDiscovery_UnitTest is fully constructed.

   278 		@post			CRegistrar_RegisterDiscovery_UnitTest is fully destroyed.

   279 	*/

   280 	~CRegistrar_RegisterDiscovery_UnitTest();

   281 

   282 private:

   283 	/**

   284 		@fn				CRegistrar_RegisterDiscovery_UnitTest(CDataLogger& aDataLogger,

   285 														MUnitTestObserver& aObserver)

   286 		Intended Usage	: Default constructor.

   287 		Error Condition	: None. 

   288 		@since			7.0

   289 		@param			aDataLogger The output logging object.

   290 		@param			aObserver The observer of this UnitTest.

   291 		@param			aStateAccessor WhiteBox state access to the CRegistrar class.

   292 		@pre 			None.

   293 		@post			CRegistrar_RegisterDiscovery_UnitTest is fully constructed.

   294 	*/

   295 	inline CRegistrar_RegisterDiscovery_UnitTest(CDataLogger& aDataLogger,

   296 											MUnitTestObserver& aObserver);

   297 

   298 	/**

   299 		@fn				void ConstructL()

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

   301 		to complete the object initialisation.

   302 		Error Condition	: Leaves with an error code.

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

   304 		@since			7.0

   305 		@return			None 

   306 		@pre 			CRegistrar_RegisterDiscovery_UnitTest is fully constructed.

   307 		@post			CRegistrar_RegisterDiscovery_UnitTest is fully initialised.

   308 	*/

   309 	void ConstructL();

   310 

   311 	void Notification(TInt aNotificationCode);

   312 

   313 	/**

   314 	The context of the Unit Test.

   315 	i.e The CRegistrar class tested by this UnitTest's transitions.

   316 	 */

   317 	CRegistrar_UnitTestContext* iUTContext;

   318 	TRegistrar_StateAccessor*	iStateAccessor;

   319 

   320 /** Registry data which is required for constructing a CRegistrar */

   321 	CRegistryData*	iRegistryData;

   322 

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

   324 	TRegistrar_Ctor_TransitionValidator*				iCtorValidator;

   325 	TRegistrar_RegisterDiscoveryL_TransitionValidator*	iRegisterDiscoveryValidator;

   326 	TRegistrar_Dtor_TransitionValidator*				iDtorValidator;

   327 	};	// CRegistrar_RegisterDiscovery_UnitTest

   328 

   329 // ______________________________________________________________________________

   330 //

   331 /**

   332 	@internalComponent

   333 	Comments : Unit Test for RegisterDiscovery on CRegistrar, the class under test.

   334  */

   335 class CRegistrar_RegisterTwice_UnitTest : public CUnitTest, private MRegistrarObserver

   336 	{

   337 public:

   338 	/**

   339 		@fn				NewL(CDataLogger& aDataLogger,

   340 							MUnitTestObserver& aObserver)

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

   342 						cleanup stack.

   343 		Error Condition	: Leaves with the error code.

   344 		@leave  		KErrNoMemory

   345 		@since			7.0

   346 		@param			aDataLogger The output logging object.

   347 		@param			aObserver The observer of this UnitTest.

   348 		@return			CRegistrar_RegisterTwice_UnitTest* The constructed object.

   349 		@pre 			None.

   350 		@post			CRegistrar_RegisterTwice_UnitTest is fully constructed, and initialised.

   351 	 */

   352 	static CRegistrar_RegisterTwice_UnitTest* NewL(CDataLogger& aDataLogger,

   353 											MUnitTestObserver& aObserver);

   354 

   355 	/**

   356 		@fn				RunError(TInt aError)

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

   358 						to restore the CRegistrar_RegisterTwice_UnitTest

   359 						object to a sensible state.

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

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

   362 		@since			7.0

   363 		@return			TInt KErrNone if cleanup successful, otherwise

   364 						@see CUnitTest::RunError()

   365 		@pre 			CRegistrar_RegisterTwice_UnitTest is fully constructed, and initialised.

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

   367 	 */

   368 	inline TInt RunError(TInt aError);

   369 

   370 	/**

   371 		@fn				~CRegistrar_RegisterTwice_UnitTest()

   372 		Intended Usage	: Standard Destructor.

   373 		Error Condition	: None.	

   374 		@since			7.0

   375 		@pre 			CRegistrar_RegisterTwice_UnitTest is fully constructed.

   376 		@post			CRegistrar_RegisterTwice_UnitTest is fully destroyed.

   377 	*/

   378 	~CRegistrar_RegisterTwice_UnitTest();

   379 

   380 private:

   381 	/**

   382 		@fn				CRegistrar_RegisterTwice_UnitTest(CDataLogger& aDataLogger,

   383 														MUnitTestObserver& aObserver)

   384 		Intended Usage	: Default constructor.

   385 		Error Condition	: None. 

   386 		@since			7.0

   387 		@param			aDataLogger The output logging object.

   388 		@param			aObserver The observer of this UnitTest.

   389 		@param			aStateAccessor WhiteBox state access to the CRegistrar class.

   390 		@pre 			None.

   391 		@post			CRegistrar_RegisterTwice_UnitTest is fully constructed.

   392 	*/

   393 	inline CRegistrar_RegisterTwice_UnitTest(CDataLogger& aDataLogger,

   394 											MUnitTestObserver& aObserver);

   395 

   396 	/**

   397 		@fn				void ConstructL()

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

   399 		to complete the object initialisation.

   400 		Error Condition	: Leaves with an error code.

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

   402 		@since			7.0

   403 		@return			None 

   404 		@pre 			CRegistrar_RegisterTwice_UnitTest is fully constructed.

   405 		@post			CRegistrar_RegisterTwice_UnitTest is fully initialised.

   406 	*/

   407 	void ConstructL();

   408 

   409 	void Notification(TInt aNotificationCode);

   410 

   411 	/**

   412 	The context of the Unit Test.

   413 	i.e The CRegistrar class tested by this UnitTest's transitions.

   414 	 */

   415 	CRegistrar_UnitTestContext* iUTContext;

   416 	TRegistrar_StateAccessor*	iStateAccessor;

   417 

   418 /** Registry data which is required for constructing a CRegistrar */

   419 	CRegistryData*	iRegistryData;

   420 

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

   422 	TRegistrar_Ctor_TransitionValidator*				iCtorValidator;

   423 	TRegistrar_RegisterDiscoveryL_TransitionValidator*	iRegisterDiscoveryValidator;

   424 	TRegistrar_Default_TransitionValidator*				iDefaultValidator;

   425 	TRegistrar_Dtor_TransitionValidator*				iDtorValidator;

   426 	};	// CRegistrar_RegisterTwice_UnitTest

   427 

   428 

   429 // ______________________________________________________________________________

   430 //

   431 /**

   432 	@internalComponent

   433 	Comments : Unit Test for RegisterDiscovery on CRegistrar, the class under test.

   434  */

   435 class CRegistrar_UseWhileDiscovering_UnitTest : public CUnitTest, private MRegistrarObserver

   436 	{

   437 public:

   438 	/**

   439 		@fn				NewL(CDataLogger& aDataLogger,

   440 							MUnitTestObserver& aObserver)

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

   442 						cleanup stack.

   443 		Error Condition	: Leaves with the error code.

   444 		@leave  		KErrNoMemory

   445 		@since			7.0

   446 		@param			aDataLogger The output logging object.

   447 		@param			aObserver The observer of this UnitTest.

   448 		@return			CRegistrar_UseWhileDiscovering_UnitTest* The constructed object.

   449 		@pre 			None.

   450 		@post			CRegistrar_UseWhileDiscovering_UnitTest is fully constructed, and initialised.

   451 	 */

   452 	static CRegistrar_UseWhileDiscovering_UnitTest* NewL(CDataLogger& aDataLogger,

   453 											MUnitTestObserver& aObserver);

   454 

   455 	/**

   456 		@fn				RunError(TInt aError)

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

   458 						to restore the CRegistrar_UseWhileDiscovering_UnitTest

   459 						object to a sensible state.

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

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

   462 		@since			7.0

   463 		@return			TInt KErrNone if cleanup successful, otherwise

   464 						@see CUnitTest::RunError()

   465 		@pre 			CRegistrar_UseWhileDiscovering_UnitTest is fully constructed, and initialised.

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

   467 	 */

   468 	inline TInt RunError(TInt aError);

   469 

   470 	/**

   471 		@fn				~CRegistrar_UseWhileDiscovering_UnitTest()

   472 		Intended Usage	: Standard Destructor.

   473 		Error Condition	: None.	

   474 		@since			7.0

   475 		@pre 			CRegistrar_UseWhileDiscovering_UnitTest is fully constructed.

   476 		@post			CRegistrar_UseWhileDiscovering_UnitTest is fully destroyed.

   477 	*/

   478 	~CRegistrar_UseWhileDiscovering_UnitTest();

   479 

   480 private:

   481 	/**

   482 		@fn				CRegistrar_UseWhileDiscovering_UnitTest(CDataLogger& aDataLogger,

   483 														MUnitTestObserver& aObserver)

   484 		Intended Usage	: Default constructor.

   485 		Error Condition	: None. 

   486 		@since			7.0

   487 		@param			aDataLogger The output logging object.

   488 		@param			aObserver The observer of this UnitTest.

   489 		@param			aStateAccessor WhiteBox state access to the CRegistrar class.

   490 		@pre 			None.

   491 		@post			CRegistrar_UseWhileDiscovering_UnitTest is fully constructed.

   492 	*/

   493 	inline CRegistrar_UseWhileDiscovering_UnitTest(CDataLogger& aDataLogger,

   494 											MUnitTestObserver& aObserver);

   495 

   496 	/**

   497 		@fn				void ConstructL()

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

   499 		to complete the object initialisation.

   500 		Error Condition	: Leaves with an error code.

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

   502 		@since			7.0

   503 		@return			None 

   504 		@pre 			CRegistrar_UseWhileDiscovering_UnitTest is fully constructed.

   505 		@post			CRegistrar_UseWhileDiscovering_UnitTest is fully initialised.

   506 	*/

   507 	void ConstructL();

   508 

   509 	void Notification(TInt aNotificationCode);

   510 

   511 	/**

   512 	The context of the Unit Test.

   513 	i.e The CRegistrar class tested by this UnitTest's transitions.

   514 	 */

   515 	CRegistrar_UnitTestContext* iUTContext;

   516 	TRegistrar_StateAccessor*	iStateAccessor;

   517 

   518 /** Registry data which is required for constructing a CRegistrar */

   519 	CRegistryData*	iRegistryData;

   520 

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

   522 	TRegistrar_Ctor_TransitionValidator*				iCtorValidator;

   523 	TRegistrar_CheckRegWhileDiscovering_TransitionValidator*	iCheckRegValidator;

   524 	TRegistrar_Dtor_TransitionValidator*				iDtorValidator;

   525 	};	// CRegistrar_UseWhileDiscovering_UnitTest

   526 

   527 #include "RegistrarUnitTests.inl"

   528 

   529 #endif		// __REGISTRARUNITTESTS_H__