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 // Definition of the CDiscoverer Unit Test classes.

    15 // 

    16 //

    17 

    18 #ifndef __DISCOVERERUNITTEST_H__

    19 #define __DISCOVERERUNITTEST_H__

    20 

    21 

    22 #include <test_bed/testbeddefinitions.h>

    23 #include "DiscovererStateAccessor.h"

    24 #include "DiscovererTransitionValidation.h"

    25 #include "DiscovererTransitions.h"

    26 

    27 // ______________________________________________________________________________

    28 //

    29 /**

    30 	@internalComponent

    31 

    32 	Comments : Unit Test for CreateAndDestroy on CDiscoverer, the class under test.

    33  */

    34 class CDiscoverer_CreateAndDestroy_UnitTest : public CUnitTest

    35 	{

    36 public:

    37 	/**

    38 		@fn				NewL(CDataLogger& aDataLogger,

    39 							MUnitTestObserver& aObserver)

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

    41 						cleanup stack.

    42 		Error Condition	: Leaves with the error code.

    43 		@leave			KErrNoMemory

    44 		@since			7.0

    45 		@param			aDataLogger The output logging object.

    46 		@param			aObserver The observer of this UnitTest.

    47 		@return			CDiscoverer_CreateAndDestroy_UnitTest* The constructed object.

    48 		@pre 			None.

    49 		@post			CDiscoverer_CreateAndDestroy_UnitTest is fully constructed, and initialised.

    50 	 */

    51 	static CDiscoverer_CreateAndDestroy_UnitTest* NewL(CDataLogger& aDataLogger,

    52 											MUnitTestObserver& aObserver);

    53 

    54 	/**

    55 		@fn				RunError(TInt aError)

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

    57 						to restore the CDiscoverer_CreateAndDestroy_UnitTest

    58 						object to a sensible state.

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

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

    61 		@since			7.0

    62 		@return			TInt KErrNone if cleanup successful, otherwise

    63 						@see CUnitTest::RunError()

    64 		@pre 			CDiscoverer_CreateAndDestroy_UnitTest is fully constructed, and initialised.

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

    66 	 */

    67 	inline TInt RunError(TInt aError);

    68 

    69 	/**

    70 		@fn				~CDiscoverer_CreateAndDestroy_UnitTest()

    71 		Intended Usage	: Standard Destructor.

    72 		Error Condition	: None.	

    73 		@since			7.0

    74 		@pre 			CDiscoverer_CreateAndDestroy_UnitTest is fully constructed.

    75 		@post			CDiscoverer_CreateAndDestroy_UnitTest is fully destroyed.

    76 	*/

    77 	~CDiscoverer_CreateAndDestroy_UnitTest();

    78 

    79 /**

    80 	@fn				PrepareUnitTestL()

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

    82 					any test preparation to take place.

    83 	Error Condition	: Leaves with an error code.

    84 	@leave			KErrNoMemory

    85 	@since			7.0

    86 	@pre 			CDiscoverer_CreateAndDestroy_UnitTest is fully constructed.

    87 	@post			This unit test is ready to run.

    88 */

    89 	void PrepareUnitTestL();

    90 

    91 private:

    92 	/**

    93 		@fn				CDiscoverer_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

    94 														MUnitTestObserver& aObserver)

    95 		Intended Usage	: Default constructor.

    96 		Error Condition	: None. 

    97 		@since			7.0

    98 		@param			aDataLogger The output logging object.

    99 		@param			aObserver The observer of this UnitTest.

   100 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   101 		@pre 			None.

   102 		@post			CDiscoverer_CreateAndDestroy_UnitTest is fully constructed.

   103 	*/

   104 	inline CDiscoverer_CreateAndDestroy_UnitTest(CDataLogger& aDataLogger,

   105 											MUnitTestObserver& aObserver);

   106 

   107 	/**

   108 		@fn				void ConstructL()

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

   110 		to complete the object initialisation.

   111 		Error Condition	: Leaves with an error code.

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

   113 		@since			7.0

   114 		@return			None 

   115 		@pre 			CDiscoverer_CreateAndDestroy_UnitTest is fully constructed.

   116 		@post			CDiscoverer_CreateAndDestroy_UnitTest is fully initialised.

   117 	*/

   118 	void ConstructL();

   119 

   120 	/**

   121 	The context of the Unit Test.

   122 	i.e The CDiscoverer class tested by this UnitTest's transitions.

   123 	 */

   124 	CDiscoverer_UnitTestContext*				iUTContext;

   125 	TDiscoverer_Ctor_TransitionValidator*		iCtorValidator;

   126 	TDiscoverer_Dtor_TransitionValidator*		iDtorValidator;

   127 	TDiscoverer_StateAccessor*	iStateAccessor;

   128 	};	// CDiscoverer_CreateAndDestroy_UnitTest

   129 

   130 // ______________________________________________________________________________

   131 //

   132 /**

   133 	@internalComponent

   134 

   135 	Comments : Unit Test for MountDrive on CDiscoverer, the class under test.

   136  */

   137 class CDiscoverer_MountDrive_UnitTest : public CUnitTest

   138 	{

   139 public:

   140 	/**

   141 		@fn				NewL(CDataLogger& aDataLogger,

   142 							MUnitTestObserver& aObserver)

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

   144 						cleanup stack.

   145 		Error Condition	: Leaves with the error code.

   146 		@leave  		KErrNoMemory

   147 		@since			7.0

   148 		@param			aDataLogger The output logging object.

   149 		@param			aObserver The observer of this UnitTest.

   150 		@return			CDiscoverer_MountDrive_UnitTest* The constructed object.

   151 		@pre 			None.

   152 		@post			CDiscoverer_MountDrive_UnitTest is fully constructed, and initialised.

   153 	 */

   154 	static CDiscoverer_MountDrive_UnitTest* NewL(CDataLogger& aDataLogger,

   155 											MUnitTestObserver& aObserver);

   156 

   157 	/**

   158 		@fn				RunError(TInt aError)

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

   160 						to restore the CDiscoverer_MountDrive_UnitTest

   161 						object to a sensible state.

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

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

   164 		@since			7.0

   165 		@return			TInt KErrNone if cleanup successful, otherwise

   166 						@see CUnitTest::RunError()

   167 		@pre 			CDiscoverer_MountDrive_UnitTest is fully constructed, and initialised.

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

   169 	 */

   170 	inline TInt RunError(TInt aError);

   171 

   172 	/**

   173 		@fn				~CDiscoverer_MountDrive_UnitTest()

   174 		Intended Usage	: Standard Destructor.

   175 		Error Condition	: None.	

   176 		@since			7.0

   177 		@pre 			CDiscoverer_MountDrive_UnitTest is fully constructed.

   178 		@post			CDiscoverer_MountDrive_UnitTest is fully destroyed.

   179 	*/

   180 	~CDiscoverer_MountDrive_UnitTest();

   181 

   182 private:

   183 	/**

   184 		@fn				CDiscoverer_MountDrive_UnitTest(CDataLogger& aDataLogger,

   185 														MUnitTestObserver& aObserver)

   186 		Intended Usage	: Default constructor.

   187 		Error Condition	: None. 

   188 		@since			7.0

   189 		@param			aDataLogger The output logging object.

   190 		@param			aObserver The observer of this UnitTest.

   191 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   192 		@pre 			None.

   193 		@post			CDiscoverer_MountDrive_UnitTest is fully constructed.

   194 	*/

   195 	inline CDiscoverer_MountDrive_UnitTest(CDataLogger& aDataLogger,

   196 											MUnitTestObserver& aObserver);

   197 

   198 	/**

   199 		@fn				void ConstructL()

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

   201 		to complete the object initialisation.

   202 		Error Condition	: Leaves with an error code.

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

   204 		@since			7.0

   205 		@return			None 

   206 		@pre 			CDiscoverer_MountDrive_UnitTest is fully constructed.

   207 		@post			CDiscoverer_MountDrive_UnitTest is fully initialised.

   208 	*/

   209 	void ConstructL();

   210 

   211 	/**

   212 	The context of the Unit Test.

   213 	i.e The CDiscoverer class tested by this UnitTest's transitions.

   214 	 */

   215 	CDiscoverer_UnitTestContext* iUTContext;

   216 	TDiscoverer_StateAccessor*	iStateAccessor;

   217 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

   218 	TDiscoverer_MountDriveL_TransitionValidator*	iMountValidator;

   219 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

   220 	};	// CDiscoverer_MountDrive_UnitTest

   221 

   222 // ______________________________________________________________________________

   223 //

   224 /**

   225 	@internalComponent

   226 

   227 	Comments : Unit Test for UnmountDrive on CDiscoverer, the class under test.

   228  */

   229 class CDiscoverer_UnmountDrive_UnitTest : public CUnitTest

   230 	{

   231 public:

   232 	/**

   233 		@fn				NewL(CDataLogger& aDataLogger,

   234 							MUnitTestObserver& aObserver)

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

   236 						cleanup stack.

   237 		Error Condition	: Leaves with the error code.

   238 		@leave  		KErrNoMemory

   239 		@since			7.0

   240 		@param			aDataLogger The output logging object.

   241 		@param			aObserver The observer of this UnitTest.

   242 		@return			CDiscoverer_UnmountDrive_UnitTest* The constructed object.

   243 		@pre 			None.

   244 		@post			CDiscoverer_UnmountDrive_UnitTest is fully constructed, and initialised.

   245 	 */

   246 	static CDiscoverer_UnmountDrive_UnitTest* NewL(CDataLogger& aDataLogger,

   247 											MUnitTestObserver& aObserver);

   248 

   249 	/**

   250 		@fn				RunError(TInt aError)

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

   252 						to restore the CDiscoverer_UnmountDrive_UnitTest

   253 						object to a sensible state.

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

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

   256 		@since			7.0

   257 		@return			TInt KErrNone if cleanup successful, otherwise

   258 						@see CUnitTest::RunError()

   259 		@pre 			CDiscoverer_UnmountDrive_UnitTest is fully constructed, and initialised.

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

   261 	 */

   262 	inline TInt RunError(TInt aError);

   263 

   264 	/**

   265 		@fn				~CDiscoverer_UnmountDrive_UnitTest()

   266 		Intended Usage	: Standard Destructor.

   267 		Error Condition	: None.	

   268 		@since			7.0

   269 		@pre 			CDiscoverer_UnmountDrive_UnitTest is fully constructed.

   270 		@post			CDiscoverer_UnmountDrive_UnitTest is fully destroyed.

   271 	*/

   272 	~CDiscoverer_UnmountDrive_UnitTest();

   273 

   274 private:

   275 	/**

   276 		@fn				CDiscoverer_UnmountDrive_UnitTest(CDataLogger& aDataLogger,

   277 														MUnitTestObserver& aObserver)

   278 		Intended Usage	: Default constructor.

   279 		Error Condition	: None. 

   280 		@since			7.0

   281 		@param			aDataLogger The output logging object.

   282 		@param			aObserver The observer of this UnitTest.

   283 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   284 		@pre 			None.

   285 		@post			CDiscoverer_UnmountDrive_UnitTest is fully constructed.

   286 	*/

   287 	inline CDiscoverer_UnmountDrive_UnitTest(CDataLogger& aDataLogger,

   288 											MUnitTestObserver& aObserver);

   289 

   290 	/**

   291 		@fn				void ConstructL()

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

   293 		to complete the object initialisation.

   294 		Error Condition	: Leaves with an error code.

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

   296 		@since			7.0

   297 		@return			None 

   298 		@pre 			CDiscoverer_UnmountDrive_UnitTest is fully constructed.

   299 		@post			CDiscoverer_UnmountDrive_UnitTest is fully initialised.

   300 	*/

   301 	void ConstructL();

   302 

   303 	/**

   304 	The context of the Unit Test.

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

   306 	 */

   307 	CDiscoverer_UnitTestContext* iUTContext;

   308 	TDiscoverer_StateAccessor*	iStateAccessor;

   309 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

   310 	TDiscoverer_UnmountDrive_TransitionValidator*	iUnmountValidator;

   311 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

   312 	};	// CDiscoverer_UnmountDrive_UnitTest

   313 

   314 // ______________________________________________________________________________

   315 //

   316 /**

   317 	@internalComponent

   318 

   319 	Comments : Unit Test for IsValidEntryL on CDiscoverer, the class under test.

   320  */

   321 class CDiscoverer_IsValidEntryL_UnitTest : public CUnitTest

   322 	{

   323 public:

   324 	/**

   325 		@fn				NewL(CDataLogger& aDataLogger,

   326 							MUnitTestObserver& aObserver)

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

   328 						cleanup stack.

   329 		Error Condition	: Leaves with the error code.

   330 		@leave  		KErrNoMemory

   331 		@since			7.0

   332 		@param			aDataLogger The output logging object.

   333 		@param			aObserver The observer of this UnitTest.

   334 		@return			CDiscoverer_IsValidEntryL_UnitTest* The constructed object.

   335 		@pre 			None.

   336 		@post			CDiscoverer_IsValidEntryL_UnitTest is fully constructed, and initialised.

   337 	 */

   338 	static CDiscoverer_IsValidEntryL_UnitTest* NewL(CDataLogger& aDataLogger,

   339 											MUnitTestObserver& aObserver);

   340 

   341 	/**

   342 		@fn				RunError(TInt aError)

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

   344 						to restore the CDiscoverer_IsValidEntryL_UnitTest

   345 						object to a sensible state.

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

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

   348 		@since			7.0

   349 		@return			TInt KErrNone if cleanup successful, otherwise

   350 						@see CUnitTest::RunError()

   351 		@pre 			CDiscoverer_IsValidEntryL_UnitTest is fully constructed, and initialised.

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

   353 	 */

   354 	inline TInt RunError(TInt aError);

   355 

   356 	/**

   357 		@fn				~CDiscoverer_IsValidEntryL_UnitTest()

   358 		Intended Usage	: Standard Destructor.

   359 		Error Condition	: None.	

   360 		@since			7.0

   361 		@pre 			CDiscoverer_IsValidEntryL_UnitTest is fully constructed.

   362 		@post			CDiscoverer_IsValidEntryL_UnitTest is fully destroyed.

   363 	*/

   364 	~CDiscoverer_IsValidEntryL_UnitTest();

   365 

   366 /**

   367 	@fn				PrepareUnitTestL()

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

   369 					any test preparation to take place.

   370 	Error Condition	: 

   371 	@since			7.0

   372 	@pre 			CDiscoverer_CreateAndDestroy_UnitTest is fully constructed.

   373 	@post			This unit test is ready to run.

   374 */

   375 	void PrepareUnitTestL();

   376 

   377 private:

   378 	/**

   379 		@fn				CDiscoverer_IsValidEntryL_UnitTest(CDataLogger& aDataLogger,

   380 														MUnitTestObserver& aObserver)

   381 		Intended Usage	: Default constructor.

   382 		Error Condition	: None. 

   383 		@since			7.0

   384 		@param			aDataLogger The output logging object.

   385 		@param			aObserver The observer of this UnitTest.

   386 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   387 		@pre 			None.

   388 		@post			CDiscoverer_IsValidEntryL_UnitTest is fully constructed.

   389 	*/

   390 	inline CDiscoverer_IsValidEntryL_UnitTest(CDataLogger& aDataLogger,

   391 											MUnitTestObserver& aObserver);

   392 

   393 	/**

   394 		@fn				void ConstructL()

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

   396 		to complete the object initialisation.

   397 		Error Condition	: Leaves with an error code.

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

   399 		@since			7.0

   400 		@return			None 

   401 		@pre 			CDiscoverer_IsValidEntryL_UnitTest is fully constructed.

   402 		@post			CDiscoverer_IsValidEntryL_UnitTest is fully initialised.

   403 	*/

   404 	void ConstructL();

   405 

   406 	/**

   407 	The context of the Unit Test.

   408 	i.e The CDiscoverer class tested by this UnitTest's transitions.

   409 	 */

   410 	CDiscoverer_UnitTestContext* iUTContext;

   411 	TDiscoverer_StateAccessor*	iStateAccessor;

   412 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

   413 	TDiscoverer_IsValidEntry_TransitionValidator*	iIsValidEntryValidator;

   414 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

   415 	};	// CDiscoverer_IsValidEntryL_UnitTest

   416 

   417 // ______________________________________________________________________________

   418 //

   419 /**

   420 	@internalComponent

   421 

   422 	Comments : Unit Test for ProcessEntryL on CDiscoverer, the class under test.

   423  */

   424 class CDiscoverer_ProcessEntryL_UnitTest : public CUnitTest

   425 	{

   426 public:

   427 	/**

   428 		@fn				NewL(CDataLogger& aDataLogger,

   429 							MUnitTestObserver& aObserver)

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

   431 						cleanup stack.

   432 		Error Condition	: Leaves with the error code.

   433 		@leave  		KErrNoMemory

   434 		@since			7.0

   435 		@param			aDataLogger The output logging object.

   436 		@param			aObserver The observer of this UnitTest.

   437 		@return			CDiscoverer_ProcessEntryL_UnitTest* The constructed object.

   438 		@pre 			None.

   439 		@post			CDiscoverer_ProcessEntryL_UnitTest is fully constructed, and initialised.

   440 	 */

   441 	static CDiscoverer_ProcessEntryL_UnitTest* NewL(CDataLogger& aDataLogger,

   442 											MUnitTestObserver& aObserver);

   443 

   444 	/**

   445 		@fn				RunError(TInt aError)

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

   447 						to restore the CDiscoverer_ProcessEntryL_UnitTest

   448 						object to a sensible state.

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

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

   451 		@since			7.0

   452 		@return			TInt KErrNone if cleanup successful, otherwise

   453 						@see CUnitTest::RunError()

   454 		@pre 			CDiscoverer_ProcessEntryL_UnitTest is fully constructed, and initialised.

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

   456 	 */

   457 	inline TInt RunError(TInt aError);

   458 

   459 	/**

   460 		@fn				~CDiscoverer_ProcessEntryL_UnitTest()

   461 		Intended Usage	: Standard Destructor.

   462 		Error Condition	: None.	

   463 		@since			7.0

   464 		@pre 			CDiscoverer_ProcessEntryL_UnitTest is fully constructed.

   465 		@post			CDiscoverer_ProcessEntryL_UnitTest is fully destroyed.

   466 	*/

   467 	~CDiscoverer_ProcessEntryL_UnitTest();

   468 

   469 private:

   470 	/**

   471 		@fn				CDiscoverer_ProcessEntryL_UnitTest(CDataLogger& aDataLogger,

   472 														MUnitTestObserver& aObserver)

   473 		Intended Usage	: Default constructor.

   474 		Error Condition	: None. 

   475 		@since			7.0

   476 		@param			aDataLogger The output logging object.

   477 		@param			aObserver The observer of this UnitTest.

   478 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   479 		@pre 			None.

   480 		@post			CDiscoverer_ProcessEntryL_UnitTest is fully constructed.

   481 	*/

   482 	inline CDiscoverer_ProcessEntryL_UnitTest(CDataLogger& aDataLogger,

   483 											MUnitTestObserver& aObserver);

   484 

   485 	/**

   486 		@fn				void ConstructL()

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

   488 		to complete the object initialisation.

   489 		Error Condition	: Leaves with an error code.

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

   491 		@since			7.0

   492 		@return			None 

   493 		@pre 			CDiscoverer_ProcessEntryL_UnitTest is fully constructed.

   494 		@post			CDiscoverer_ProcessEntryL_UnitTest is fully initialised.

   495 	*/

   496 	void ConstructL();

   497 

   498 	/**

   499 	The context of the Unit Test.

   500 	i.e The CDiscoverer class tested by this UnitTest's transitions.

   501 	 */

   502 	CDiscoverer_UnitTestContext* iUTContext;

   503 	TDiscoverer_StateAccessor*	iStateAccessor;

   504 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

   505 	TDiscoverer_ProcessEntryL_TransitionValidator*	iProcessEntryValidator;

   506 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

   507 	};	// CDiscoverer_ProcessEntryL_UnitTest

   508 

   509 // ______________________________________________________________________________

   510 //

   511 /**

   512 	@internalComponent

   513 

   514 	Comments : Unit Test for CompleteNotificationProcessing on CDiscoverer, the class under test.

   515  */

   516 class CDiscoverer_CompleteNotificationProcessing_UnitTest : public CUnitTest

   517 	{

   518 public:

   519 	/**

   520 		@fn				NewL(CDataLogger& aDataLogger,

   521 							MUnitTestObserver& aObserver)

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

   523 						cleanup stack.

   524 		Error Condition	: Leaves with the error code.

   525 		@leave			KErrNoMemory

   526 		@since			7.0

   527 		@param			aDataLogger The output logging object.

   528 		@param			aObserver The observer of this UnitTest.

   529 		@return			CDiscoverer_CompleteNotificationProcessing_UnitTest* The constructed object.

   530 		@pre 			None.

   531 		@post			CDiscoverer_CompleteNotificationProcessing_UnitTest is fully constructed, and initialised.

   532 	 */

   533 	static CDiscoverer_CompleteNotificationProcessing_UnitTest* NewL(CDataLogger& aDataLogger,

   534 											MUnitTestObserver& aObserver);

   535 

   536 	/**

   537 		@fn				RunError(TInt aError)

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

   539 						to restore the CDiscoverer_CompleteNotificationProcessing_UnitTest

   540 						object to a sensible state.

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

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

   543 		@since			7.0

   544 		@return			TInt KErrNone if cleanup successful, otherwise

   545 						@see CUnitTest::RunError()

   546 		@pre 			CDiscoverer_CompleteNotificationProcessing_UnitTest is fully constructed, and initialised.

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

   548 	 */

   549 	inline TInt RunError(TInt aError);

   550 

   551 	/**

   552 		@fn				~CDiscoverer_CompleteNotificationProcessing_UnitTest()

   553 		Intended Usage	: Standard Destructor.

   554 		Error Condition	: None.	

   555 		@since			7.0

   556 		@pre 			CDiscoverer_CompleteNotificationProcessing_UnitTest is fully constructed.

   557 		@post			CDiscoverer_CompleteNotificationProcessing_UnitTest is fully destroyed.

   558 	*/

   559 	~CDiscoverer_CompleteNotificationProcessing_UnitTest();

   560 

   561 private:

   562 	/**

   563 		@fn				CDiscoverer_CompleteNotificationProcessing_UnitTest(CDataLogger& aDataLogger,

   564 														MUnitTestObserver& aObserver)

   565 		Intended Usage	: Default constructor.

   566 		Error Condition	: None. 

   567 		@since			7.0

   568 		@param			aDataLogger The output logging object.

   569 		@param			aObserver The observer of this UnitTest.

   570 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   571 		@pre 			None.

   572 		@post			CDiscoverer_CompleteNotificationProcessing_UnitTest is fully constructed.

   573 	*/

   574 	inline CDiscoverer_CompleteNotificationProcessing_UnitTest(CDataLogger& aDataLogger,

   575 											MUnitTestObserver& aObserver);

   576 

   577 	/**

   578 		@fn				void ConstructL()

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

   580 		to complete the object initialisation.

   581 		Error Condition	: Leaves with an error code.

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

   583 		@since			7.0

   584 		@return			None 

   585 		@pre 			CDiscoverer_CompleteNotificationProcessing_UnitTest is fully constructed.

   586 		@post			CDiscoverer_CompleteNotificationProcessing_UnitTest is fully initialised.

   587 	*/

   588 	void ConstructL();

   589 

   590 	/**

   591 	The context of the Unit Test.

   592 	i.e The CDiscoverer class tested by this UnitTest's transitions.

   593 	 */

   594 	CDiscoverer_UnitTestContext* iUTContext;

   595 	TDiscoverer_StateAccessor*	iStateAccessor;

   596 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

   597 	TDiscoverer_CompleteNotificationProcessing_TransitionValidator*	iCompleteNotificationProcessingValidator;

   598 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

   599 	};	// CDiscoverer_CompleteNotificationProcessing_UnitTest

   600 

   601 

   602 // ______________________________________________________________________________

   603 //

   604 /**

   605 	@internalComponent

   606 

   607 	Comments : Unit Test for Notification on CDiscoverer, the class under test.

   608  */

   609 class CDiscoverer_Notification_UnitTest : public CUnitTest

   610 	{

   611 public:

   612 	/**

   613 		@fn				NewL(CDataLogger& aDataLogger,

   614 							MUnitTestObserver& aObserver)

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

   616 						cleanup stack.

   617 		Error Condition	: Leaves with the error code.

   618 		@leave			KErrNoMemory

   619 		@since			7.0

   620 		@param			aDataLogger The output logging object.

   621 		@param			aObserver The observer of this UnitTest.

   622 		@return			CDiscoverer_Notification_UnitTest* The constructed object.

   623 		@pre 			None.

   624 		@post			CDiscoverer_Notification_UnitTest is fully constructed, and initialised.

   625 	 */

   626 	static CDiscoverer_Notification_UnitTest* NewL(CDataLogger& aDataLogger,

   627 											MUnitTestObserver& aObserver);

   628 

   629 	/**

   630 		@fn				RunError(TInt aError)

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

   632 						to restore the CDiscoverer_Notification_UnitTest

   633 						object to a sensible state.

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

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

   636 		@since			7.0

   637 		@return			TInt KErrNone if cleanup successful, otherwise

   638 						@see CUnitTest::RunError()

   639 		@pre 			CDiscoverer_Notification_UnitTest is fully constructed, and initialised.

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

   641 	 */

   642 	inline TInt RunError(TInt aError);

   643 

   644 	/**

   645 		@fn				~CDiscoverer_Notification_UnitTest()

   646 		Intended Usage	: Standard Destructor.

   647 		Error Condition	: None.	

   648 		@since			7.0

   649 		@pre 			CDiscoverer_Notification_UnitTest is fully constructed.

   650 		@post			CDiscoverer_Notification_UnitTest is fully destroyed.

   651 	*/

   652 	~CDiscoverer_Notification_UnitTest();

   653 

   654 private:

   655 	/**

   656 		@fn				CDiscoverer_Notification_UnitTest(CDataLogger& aDataLogger,

   657 														MUnitTestObserver& aObserver)

   658 		Intended Usage	: Default constructor.

   659 		Error Condition	: None. 

   660 		@since			7.0

   661 		@param			aDataLogger The output logging object.

   662 		@param			aObserver The observer of this UnitTest.

   663 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   664 		@pre 			None.

   665 		@post			CDiscoverer_Notification_UnitTest is fully constructed.

   666 	*/

   667 	inline CDiscoverer_Notification_UnitTest(CDataLogger& aDataLogger,

   668 											MUnitTestObserver& aObserver);

   669 

   670 	/**

   671 		@fn				void ConstructL()

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

   673 		to complete the object initialisation.

   674 		Error Condition	: Leaves with an error code.

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

   676 		@since			7.0

   677 		@return			None 

   678 		@pre 			CDiscoverer_Notification_UnitTest is fully constructed.

   679 		@post			CDiscoverer_Notification_UnitTest is fully initialised.

   680 	*/

   681 	void ConstructL();

   682 

   683 	/**

   684 	The context of the Unit Test.

   685 	i.e The CDiscoverer class tested by this UnitTest's transitions.

   686 	 */

   687 	CDiscoverer_UnitTestContext* iUTContext;

   688 	TDiscoverer_StateAccessor*	iStateAccessor;

   689 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

   690 	TDiscoverer_Notification_TransitionValidator*	iNotificationValidator;

   691 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

   692 	};	// CDiscoverer_Notification_UnitTest

   693 

   694 

   695 

   696 // ______________________________________________________________________________

   697 //

   698 /**

   699 	@internalComponent

   700 

   701 	Comments : Unit Test for SuspendResume on CDiscoverer, the class under test.

   702 

   703  */

   704 class CDiscoverer_SuspendResume_UnitTest : public CUnitTest

   705 	{

   706 public:

   707 	/**

   708 		@fn				NewL(CDataLogger& aDataLogger,

   709 							MUnitTestObserver& aObserver)

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

   711 						cleanup stack.

   712 		Error Condition	: Leaves with the error code.

   713 		@leave			KErrNoMemory

   714 		@since			7.0

   715 		@param			aDataLogger The output logging object.

   716 		@param			aObserver The observer of this UnitTest.

   717 		@return			CDiscoverer_SuspendResume_UnitTest* The constructed object.

   718 		@pre 			None.

   719 		@post			CDiscoverer_SuspendResume_UnitTest is fully constructed, and initialised.

   720 	 */

   721 	static CDiscoverer_SuspendResume_UnitTest* NewL(CDataLogger& aDataLogger,

   722 											MUnitTestObserver& aObserver);

   723 

   724 	/**

   725 		@fn				RunError(TInt aError)

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

   727 						to restore the CDiscoverer_SuspendResume_UnitTest

   728 						object to a sensible state.

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

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

   731 		@since			7.0

   732 		@return			TInt KErrNone if cleanup successful, otherwise

   733 						@see CUnitTest::RunError()

   734 		@pre 			CDiscoverer_SuspendResume_UnitTest is fully constructed, and initialised.

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

   736 	 */

   737 	inline TInt RunError(TInt aError);

   738 

   739 	/**

   740 		@fn				~CDiscoverer_SuspendResume_UnitTest()

   741 		Intended Usage	: Standard Destructor.

   742 		Error Condition	: None.	

   743 		@since			7.0

   744 		@pre 			CDiscoverer_SuspendResume_UnitTest is fully constructed.

   745 		@post			CDiscoverer_SuspendResume_UnitTest is fully destroyed.

   746 	*/

   747 	~CDiscoverer_SuspendResume_UnitTest();

   748 

   749 private:

   750 	/**

   751 		@fn				CDiscoverer_SuspendResume_UnitTest(CDataLogger& aDataLogger,

   752 														MUnitTestObserver& aObserver)

   753 		Intended Usage	: Default constructor.

   754 		Error Condition	: None. 

   755 		@since			7.0

   756 		@param			aDataLogger The output logging object.

   757 		@param			aObserver The observer of this UnitTest.

   758 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   759 		@pre 			None.

   760 		@post			CDiscoverer_SuspendResume_UnitTest is fully constructed.

   761 	*/

   762 	inline CDiscoverer_SuspendResume_UnitTest(CDataLogger& aDataLogger,

   763 											MUnitTestObserver& aObserver);

   764 

   765 	/**

   766 		@fn				void ConstructL()

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

   768 		to complete the object initialisation.

   769 		Error Condition	: Leaves with an error code.

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

   771 		@since			7.0

   772 		@return			None 

   773 		@pre 			CDiscoverer_SuspendResume_UnitTest is fully constructed.

   774 		@post			CDiscoverer_SuspendResume_UnitTest is fully initialised.

   775 	*/

   776 	void ConstructL();

   777 

   778 	/**

   779 	The context of the Unit Test.

   780 	i.e The CDiscoverer class tested by this UnitTest's transitions.

   781 	 */

   782 	CDiscoverer_UnitTestContext* iUTContext;

   783 	TDiscoverer_StateAccessor*	iStateAccessor;

   784 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

   785 	TDiscoverer_Notification_TransitionValidator*	iNotificationValidator;

   786 	TDiscoverer_Suspend_TransitionValidator*	iSuspendValidator;

   787 	TDiscoverer_Resume_TransitionValidator*	iResumeValidator;

   788 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

   789 	};	// CDiscoverer_SuspendResume_UnitTest

   790 

   791 // ______________________________________________________________________________

   792 //

   793 /**

   794 	@internalComponent

   795 

   796 	Comments : Unit Test for ScanDirectory on CDiscoverer, the class under test.

   797  */

   798 class CDiscoverer_ScanDirectory_UnitTest : public CUnitTest

   799 	{

   800 public:

   801 	/**

   802 		@fn				NewL(CDataLogger& aDataLogger,

   803 							MUnitTestObserver& aObserver)

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

   805 						cleanup stack.

   806 		Error Condition	: Leaves with the error code.

   807 		@leave			KErrNoMemory

   808 		@since			7.0

   809 		@param			aDataLogger The output logging object.

   810 		@param			aObserver The observer of this UnitTest.

   811 		@return			CDiscoverer_ScanDirectory_UnitTest* The constructed object.

   812 		@pre 			None.

   813 		@post			CDiscoverer_ScanDirectory_UnitTest is fully constructed, and initialised.

   814 	 */

   815 	static CDiscoverer_ScanDirectory_UnitTest* NewL(CDataLogger& aDataLogger,

   816 											MUnitTestObserver& aObserver);

   817 

   818 	/**

   819 		@fn				RunError(TInt aError)

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

   821 						to restore the CDiscoverer_ScanDirectory_UnitTest

   822 						object to a sensible state.

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

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

   825 		@since			7.0

   826 		@return			TInt KErrNone if cleanup successful, otherwise

   827 						@see CUnitTest::RunError()

   828 		@pre 			CDiscoverer_ScanDirectory_UnitTest is fully constructed, and initialised.

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

   830 	 */

   831 	inline TInt RunError(TInt aError);

   832 

   833 	/**

   834 		@fn				~CDiscoverer_ScanDirectory_UnitTest()

   835 		Intended Usage	: Standard Destructor.

   836 		Error Condition	: None.	

   837 		@since			7.0

   838 		@pre 			CDiscoverer_ScanDirectory_UnitTest is fully constructed.

   839 		@post			CDiscoverer_ScanDirectory_UnitTest is fully destroyed.

   840 	*/

   841 	~CDiscoverer_ScanDirectory_UnitTest();

   842 

   843 private:

   844 	/**

   845 		@fn				CDiscoverer_ScanDirectory_UnitTest(CDataLogger& aDataLogger,

   846 														MUnitTestObserver& aObserver)

   847 		Intended Usage	: Default constructor.

   848 		Error Condition	: None. 

   849 		@since			7.0

   850 		@param			aDataLogger The output logging object.

   851 		@param			aObserver The observer of this UnitTest.

   852 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   853 		@pre 			None.

   854 		@post			CDiscoverer_ScanDirectory_UnitTest is fully constructed.

   855 	*/

   856 	inline CDiscoverer_ScanDirectory_UnitTest(CDataLogger& aDataLogger,

   857 											MUnitTestObserver& aObserver);

   858 

   859 	/**

   860 		@fn				void ConstructL()

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

   862 		to complete the object initialisation.

   863 		Error Condition	: Leaves with an error code.

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

   865 		@since			7.0

   866 		@return			None 

   867 		@pre 			CDiscoverer_ScanDirectory_UnitTest is fully constructed.

   868 		@post			CDiscoverer_ScanDirectory_UnitTest is fully initialised.

   869 	*/

   870 	void ConstructL();

   871 

   872 	/**

   873 	The context of the Unit Test.

   874 	i.e The CDiscoverer class tested by this UnitTest's transitions.

   875 	 */

   876 	CDiscoverer_UnitTestContext* iUTContext;

   877 	TDiscoverer_StateAccessor*	iStateAccessor;

   878 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

   879 	TDiscoverer_ScanDirectory_TransitionValidator*	iScanDirectoryValidator;

   880 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

   881 	};	// CDiscoverer_ScanDirectory_UnitTest

   882 

   883 

   884 // ______________________________________________________________________________

   885 //

   886 /**

   887 	@internalComponent

   888 

   889 	Comments : Unit Test for ScanDirectoryCancel on CDiscoverer, the class under test.

   890 

   891  */

   892 class CDiscoverer_ScanDirectoryCancel_UnitTest : public CUnitTest

   893 	{

   894 public:

   895 	/**

   896 		@fn				NewL(CDataLogger& aDataLogger,

   897 							MUnitTestObserver& aObserver)

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

   899 						cleanup stack.

   900 		Error Condition	: Leaves with the error code.

   901 		@leave  		KErrNoMemory

   902 		@since			7.0

   903 		@param			aDataLogger The output logging object.

   904 		@param			aObserver The observer of this UnitTest.

   905 		@return			CDiscoverer_ScanDirectoryCancel_UnitTest* The constructed object.

   906 		@pre 			None.

   907 		@post			CDiscoverer_ScanDirectoryCancel_UnitTest is fully constructed, and initialised.

   908 	 */

   909 	static CDiscoverer_ScanDirectoryCancel_UnitTest* NewL(CDataLogger& aDataLogger,

   910 											MUnitTestObserver& aObserver);

   911 

   912 	/**

   913 		@fn				RunError(TInt aError)

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

   915 						to restore the CDiscoverer_ScanDirectoryCancel_UnitTest

   916 						object to a sensible state.

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

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

   919 		@since			7.0

   920 		@return			TInt KErrNone if cleanup successful, otherwise

   921 						@see CUnitTest::RunError()

   922 		@pre 			CDiscoverer_ScanDirectoryCancel_UnitTest is fully constructed, and initialised.

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

   924 	 */

   925 	inline TInt RunError(TInt aError);

   926 

   927 	/**

   928 		@fn				~CDiscoverer_ScanDirectoryCancel_UnitTest()

   929 		Intended Usage	: Standard Destructor.

   930 		Error Condition	: None.	

   931 		@since			7.0

   932 		@pre 			CDiscoverer_ScanDirectoryCancel_UnitTest is fully constructed.

   933 		@post			CDiscoverer_ScanDirectoryCancel_UnitTest is fully destroyed.

   934 	*/

   935 	~CDiscoverer_ScanDirectoryCancel_UnitTest();

   936 

   937 private:

   938 	/**

   939 		@fn				CDiscoverer_ScanDirectoryCancel_UnitTest(CDataLogger& aDataLogger,

   940 														MUnitTestObserver& aObserver)

   941 		Intended Usage	: Default constructor.

   942 		Error Condition	: None. 

   943 		@since			7.0

   944 		@param			aDataLogger The output logging object.

   945 		@param			aObserver The observer of this UnitTest.

   946 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

   947 		@pre 			None.

   948 		@post			CDiscoverer_ScanDirectoryCancel_UnitTest is fully constructed.

   949 	*/

   950 	inline CDiscoverer_ScanDirectoryCancel_UnitTest(CDataLogger& aDataLogger,

   951 											MUnitTestObserver& aObserver);

   952 

   953 	/**

   954 		@fn				void ConstructL()

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

   956 		to complete the object initialisation.

   957 		Error Condition	: Leaves with an error code.

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

   959 		@since			7.0

   960 		@return			None 

   961 		@pre 			CDiscoverer_ScanDirectoryCancel_UnitTest is fully constructed.

   962 		@post			CDiscoverer_ScanDirectoryCancel_UnitTest is fully initialised.

   963 	*/

   964 	void ConstructL();

   965 

   966 	/**

   967 	The context of the Unit Test.

   968 	i.e The CDiscoverer class tested by this UnitTest's transitions.

   969 	 */

   970 	CDiscoverer_UnitTestContext* iUTContext;

   971 	TDiscoverer_StateAccessor*	iStateAccessor;

   972 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

   973 	TDiscoverer_ScanDirectoryCancel_TransitionValidator*	iScanDirectoryCancelValidator;

   974 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

   975 	};	// CDiscoverer_ScanDirectoryCancel_UnitTest

   976 

   977 

   978 // ______________________________________________________________________________

   979 //

   980 /**

   981 	@internalComponent

   982 

   983 	Comments : Unit Test for ScanDirectoryIncrement on CDiscoverer, the class under test.

   984  */

   985 class CDiscoverer_ScanDirectoryIncrement_UnitTest : public CUnitTest

   986 	{

   987 public:

   988 	/**

   989 		@fn				NewL(CDataLogger& aDataLogger,

   990 							MUnitTestObserver& aObserver)

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

   992 						cleanup stack.

   993 		Error Condition	: Leaves with the error code.

   994 		@leave  		KErrNoMemory

   995 		@since			7.0

   996 		@param			aDataLogger The output logging object.

   997 		@param			aObserver The observer of this UnitTest.

   998 		@return			CDiscoverer_ScanDirectoryIncrement_UnitTest* The constructed object.

   999 		@pre 			None.

  1000 		@post			CDiscoverer_ScanDirectoryIncrement_UnitTest is fully constructed, and initialised.

  1001 	 */

  1002 	static CDiscoverer_ScanDirectoryIncrement_UnitTest* NewL(CDataLogger& aDataLogger,

  1003 											MUnitTestObserver& aObserver);

  1004 

  1005 	/**

  1006 		@fn				RunError(TInt aError)

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

  1008 						to restore the CDiscoverer_ScanDirectoryIncrement_UnitTest

  1009 						object to a sensible state.

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

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

  1012 		@since			7.0

  1013 		@return			TInt KErrNone if cleanup successful, otherwise

  1014 						@see CUnitTest::RunError()

  1015 		@pre 			CDiscoverer_ScanDirectoryIncrement_UnitTest is fully constructed, and initialised.

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

  1017 	 */

  1018 	inline TInt RunError(TInt aError);

  1019 

  1020 	/**

  1021 		@fn				~CDiscoverer_ScanDirectoryIncrement_UnitTest()

  1022 		Intended Usage	: Standard Destructor.

  1023 		Error Condition	: None.	

  1024 		@since			7.0

  1025 		@pre 			CDiscoverer_ScanDirectoryIncrement_UnitTest is fully constructed.

  1026 		@post			CDiscoverer_ScanDirectoryIncrement_UnitTest is fully destroyed.

  1027 	*/

  1028 	~CDiscoverer_ScanDirectoryIncrement_UnitTest();

  1029 

  1030 private:

  1031 	/**

  1032 		@fn				CDiscoverer_ScanDirectoryIncrement_UnitTest(CDataLogger& aDataLogger,

  1033 														MUnitTestObserver& aObserver)

  1034 		Intended Usage	: Default constructor.

  1035 		Error Condition	: None. 

  1036 		@since			7.0

  1037 		@param			aDataLogger The output logging object.

  1038 		@param			aObserver The observer of this UnitTest.

  1039 		@param			aStateAccessor WhiteBox state access to the CDiscoverer class.

  1040 		@pre 			None.

  1041 		@post			CDiscoverer_ScanDirectoryIncrement_UnitTest is fully constructed.

  1042 	*/

  1043 	inline CDiscoverer_ScanDirectoryIncrement_UnitTest(CDataLogger& aDataLogger,

  1044 											MUnitTestObserver& aObserver);

  1045 

  1046 	/**

  1047 		@fn				void ConstructL()

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

  1049 		to complete the object initialisation.

  1050 		Error Condition	: Leaves with an error code.

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

  1052 		@since			7.0

  1053 		@return			None 

  1054 		@pre 			CDiscoverer_ScanDirectoryIncrement_UnitTest is fully constructed.

  1055 		@post			CDiscoverer_ScanDirectoryIncrement_UnitTest is fully initialised.

  1056 	*/

  1057 	void ConstructL();

  1058 

  1059 	/**

  1060 	The context of the Unit Test.

  1061 	i.e The CDiscoverer class tested by this UnitTest's transitions.

  1062 	 */

  1063 	CDiscoverer_UnitTestContext* iUTContext;

  1064 	TDiscoverer_StateAccessor*	iStateAccessor;

  1065 	TDiscoverer_Ctor_TransitionValidator*	iCtorValidator;

  1066 	TDiscoverer_ScanDirectoryIncrement_TransitionValidator*	iScanDirectoryIncrementValidator;

  1067 	TDiscoverer_Dtor_TransitionValidator*	iDtorValidator;

  1068 	};	// CDiscoverer_ScanDirectoryIncrement_UnitTest

  1069 

  1070 #include "DiscovererUnitTest.inl"

  1071 

  1072 #endif // __DISCOVERERUNITTEST_H__

  1073