Symaptic: os/ossrv/lowlevellibsandfws/pluginfw/Framework/DiscovererTest/DiscovererUnitTest.cpp@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 // Implementation of the CDiscoverer Unit Test class methods.

    15 //

    16 //

    18 #include "DiscovererUnitTest.h"

    20 // ______________________________________________________________________________

    21 //

    23 CDiscoverer_CreateAndDestroy_UnitTest* CDiscoverer_CreateAndDestroy_UnitTest::NewL(CDataLogger& aDataLogger,

    24 											MUnitTestObserver& aObserver)

    25 	{

    26 	CDiscoverer_CreateAndDestroy_UnitTest* self =

    27 					new(ELeave) CDiscoverer_CreateAndDestroy_UnitTest(aDataLogger,

    28 																aObserver);

    29 	CleanupStack::PushL(self);

    30 	// Chain to the base which calls the ConstructL

    31 	self->ConstructL();

    32 	CleanupStack::Pop();

    33 	return self;

    34 	}

    36 // Now the Individual transitions need to be added.

    37 inline void CDiscoverer_CreateAndDestroy_UnitTest::ConstructL()

    38 	{

    39 	UnitTestConstructL();

    40 	// Create the Unit test state accessor

    41 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

    43 	// Construct the Unit test context.

    44 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

    45 	// Construct, and store the observer stub

    46 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

    48 	// and a validators

    49 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

    50 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

    52 	// Add the Transitions in the order they are to run

    53 	// C'tor first, D'tor last...

    54 	//	Examples of C'tor and D'tor transitions on CDiscoverer class.

    55 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

    56 	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

    57 	}

    59 void CDiscoverer_CreateAndDestroy_UnitTest::PrepareUnitTestL()

    60 	{

    61 	}

    63 // ______________________________________________________________________________

    64 //

    66 CDiscoverer_MountDrive_UnitTest* CDiscoverer_MountDrive_UnitTest::NewL(CDataLogger& aDataLogger,

    67 											MUnitTestObserver& aObserver)

    68 	{

    69 	CDiscoverer_MountDrive_UnitTest* self =

    70 					new(ELeave) CDiscoverer_MountDrive_UnitTest(aDataLogger,

    71 																aObserver);

    72 	CleanupStack::PushL(self);

    73 	self->ConstructL();

    74 	CleanupStack::Pop();

    75 	return self;

    76 	}

    78 // Now the Individual transitions need to be added.

    79 inline void CDiscoverer_MountDrive_UnitTest::ConstructL()

    80 	{

    81 	// Perform the base class initialization

    82 	UnitTestConstructL();

    84 	// Create the Unit test state accessor

    85 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

    86 	// Construct the Unit test context.

    87 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

    88 	// Set up the drive letter for the test (C:)

    89 	iUTContext->iDriveUnit = TDriveUnit(EDriveC);

    90 	// Construct, and store the observer stub

    91 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

    93 	// Add the Transitions in the order they are to run

    94 	// C'tor first, D'tor last...

    95 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

    96 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

    97 	iMountValidator = new(ELeave) TDiscoverer_MountDriveL_TransitionValidator(*iUTContext);

    98 	AddTransitionL(new(ELeave)CDiscoverer_MountDriveL_Transition(*iUTContext,*iMountValidator));

    99 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   100 	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   101 	}

   103 // ______________________________________________________________________________

   104 //

   106 CDiscoverer_UnmountDrive_UnitTest* CDiscoverer_UnmountDrive_UnitTest::NewL(CDataLogger& aDataLogger,

   107 											MUnitTestObserver& aObserver)

   108 	{

   109 	CDiscoverer_UnmountDrive_UnitTest* self =

   110 					new(ELeave) CDiscoverer_UnmountDrive_UnitTest(aDataLogger,

   111 																aObserver);

   112 	CleanupStack::PushL(self);

   113 	self->ConstructL();

   114 	CleanupStack::Pop();

   115 	return self;

   116 	}

   118 // Now the Individual transitions need to be added.

   119 inline void CDiscoverer_UnmountDrive_UnitTest::ConstructL()

   120 	{

   121 	// Perform the base class initialization

   122 	UnitTestConstructL();

   124 	// Create the Unit test state accessor

   125 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

   126 	// Construct the Unit test context.

   127 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

   128 	// Set up the drive letter for the test (C:)

   129 	iUTContext->iDriveUnit = TDriveUnit(EDriveC);

   130 	// Construct, and store the observer stub

   131 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

   132 	// Add the Transitions in the order they are to run

   133 	// C'tor first, D'tor last...

   134 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

   135 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

   136 	iUnmountValidator = new(ELeave) TDiscoverer_UnmountDrive_TransitionValidator(*iUTContext);

   137 	AddTransitionL(new(ELeave)CDiscoverer_UnmountDrive_Transition(*iUTContext,*iUnmountValidator));

   138 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   139 	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   140 	}

   142 // ______________________________________________________________________________

   143 //

   145 CDiscoverer_IsValidEntryL_UnitTest* CDiscoverer_IsValidEntryL_UnitTest::NewL(CDataLogger& aDataLogger,

   146 											MUnitTestObserver& aObserver)

   147 	{

   148 	CDiscoverer_IsValidEntryL_UnitTest* self =

   149 					new(ELeave) CDiscoverer_IsValidEntryL_UnitTest(aDataLogger,

   150 																aObserver);

   151 	CleanupStack::PushL(self);

   152 	self->ConstructL();

   153 	CleanupStack::Pop();

   154 	return self;

   155 	}

   157 // Now the Individual transitions need to be added.

   158 inline void CDiscoverer_IsValidEntryL_UnitTest::ConstructL()

   159 	{

   160 	_LIT(KDllFileSearchPath,"\\System\\Libs\\Plugins\\*");

   162 	// Perform the base class initialization

   163 	UnitTestConstructL();

   165 	// Create the Unit test state accessor

   166 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

   167 	// Construct the Unit test context.

   168 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

   169 	// Construct, and store the observer stub

   170 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

   171 	// and the path

   173 	// Set up the drive letter for the test (Z:)

   174 	iUTContext->iDriveUnit = TDriveUnit(EDriveZ);

   175 	TDriveName driveName(iUTContext->iDriveUnit.Name());

   176 	iUTContext->iPath.Set(KDllFileSearchPath(), NULL, &driveName);

   178 	// Add the Transitions in the order they are to run

   179 	// C'tor first, D'tor last...

   180 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

   181 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

   182 	iIsValidEntryValidator = new(ELeave) TDiscoverer_IsValidEntry_TransitionValidator(*iUTContext);

   183 	AddTransitionL(new(ELeave)CDiscoverer_IsValidEntryL_Transition(*iUTContext,*iIsValidEntryValidator));

   184 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   185 	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   186 	}

   188 inline void CDiscoverer_IsValidEntryL_UnitTest::PrepareUnitTestL()

   189 	{

   190 	_LIT(KPathForDiscovery,"Discovery Path = %S");

   191 	iDataLogger.LogInformationWithParameters(KPathForDiscovery,&(iUTContext->iPath.FullName()));

   192 	User::LeaveIfError(iFs.GetDir(iUTContext->iPath.FullName(), KEntryAttMatchExclude | KEntryAttDir, ESortByUid, iUTContext->iDir));

   193 	}

   195 // ______________________________________________________________________________

   196 //

   198 CDiscoverer_ProcessEntryL_UnitTest* CDiscoverer_ProcessEntryL_UnitTest::NewL(CDataLogger& aDataLogger,

   199 											MUnitTestObserver& aObserver)

   200 	{

   201 	CDiscoverer_ProcessEntryL_UnitTest* self =

   202 					new(ELeave) CDiscoverer_ProcessEntryL_UnitTest(aDataLogger,

   203 																aObserver);

   204 	CleanupStack::PushL(self);

   205 	self->ConstructL();

   206 	CleanupStack::Pop();

   207 	return self;

   208 	}

   210 // Now the Individual transitions need to be added.

   211 inline void CDiscoverer_ProcessEntryL_UnitTest::ConstructL()

   212 	{

   213 	// Perform the base class initialization

   214 	UnitTestConstructL();

   216 	// Create the Unit test state accessor

   217 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

   218 	// Construct the Unit test context.

   219 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

   220 	// Set up the drive letter for the test (C:)

   221 	iUTContext->iDriveUnit = TDriveUnit(EDriveC);

   222 	// Construct, and store the observer stub

   223 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

   224 	// Add the Transitions in the order they are to run

   225 	// C'tor first, D'tor last...

   226 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

   227 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

   228 	iProcessEntryValidator = new(ELeave) TDiscoverer_ProcessEntryL_TransitionValidator(*iUTContext);

   229 	AddTransitionL(new(ELeave)CDiscoverer_ProcessEntryL_Transition(*iUTContext,*iProcessEntryValidator));

   230 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   231 	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   232 	}

   234 // ______________________________________________________________________________

   235 //

   237 CDiscoverer_CompleteNotificationProcessing_UnitTest* CDiscoverer_CompleteNotificationProcessing_UnitTest::NewL(CDataLogger& aDataLogger,

   238 											MUnitTestObserver& aObserver)

   239 	{

   240 	CDiscoverer_CompleteNotificationProcessing_UnitTest* self =

   241 					new(ELeave) CDiscoverer_CompleteNotificationProcessing_UnitTest(aDataLogger,

   242 																aObserver);

   243 	CleanupStack::PushL(self);

   244 	self->ConstructL();

   245 	CleanupStack::Pop();

   246 	return self;

   247 	}

   249 // Now the Individual transitions need to be added.

   250 inline void CDiscoverer_CompleteNotificationProcessing_UnitTest::ConstructL()

   251 	{

   252 	// Perform the base class initialization

   253 	UnitTestConstructL();

   255 	// Create the Unit test state accessor

   256 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

   257 	// Construct the Unit test context.

   258 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

   259 	// Set up the drive letter for the test (C:)

   260 	iUTContext->iDriveUnit = TDriveUnit(EDriveC);

   261 	// Construct, and store the observer stub

   262 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

   263 	// Add the Transitions in the order they are to run

   264 	// C'tor first, D'tor last...

   265 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

   266 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

   268 	iCompleteNotificationProcessingValidator = new(ELeave) TDiscoverer_CompleteNotificationProcessing_TransitionValidator(*iUTContext);

   269 	AddTransitionL(new(ELeave)CDiscoverer_CompleteNotificationProcessing_Transition(*iUTContext,*iCompleteNotificationProcessingValidator));

   271 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   272 	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   273 	}

   275 // ______________________________________________________________________________

   276 //

   278 CDiscoverer_Notification_UnitTest* CDiscoverer_Notification_UnitTest::NewL(CDataLogger& aDataLogger,

   279 											MUnitTestObserver& aObserver)

   280 	{

   281 	CDiscoverer_Notification_UnitTest* self =

   282 					new(ELeave) CDiscoverer_Notification_UnitTest(aDataLogger,

   283 																aObserver);

   284 	CleanupStack::PushL(self);

   285 	self->ConstructL();

   286 	CleanupStack::Pop();

   287 	return self;

   288 	}

   290 // Now the Individual transitions need to be added.

   291 inline void CDiscoverer_Notification_UnitTest::ConstructL()

   292 	{

   293 	// Perform the base class initialization

   294 	UnitTestConstructL();

   296 	// Create the Unit test state accessor

   297 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

   298 	// Construct the Unit test context.

   299 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

   300 	// Set up the drive letter for the test (C:)

   301 	iUTContext->iDriveUnit = TDriveUnit(EDriveC);

   302 	// Construct, and store the observer stub

   303 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

   304 	// Add the Transitions in the order they are to run

   305 	// C'tor first, D'tor last...

   306 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

   307 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

   309 	iNotificationValidator = new(ELeave) TDiscoverer_Notification_TransitionValidator(*iUTContext);

   310 	AddTransitionL(new(ELeave)CDiscoverer_Notification_Transition(*iUTContext,*iNotificationValidator));

   312 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   313 	AddBlockingTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   314 	}

   315 // ______________________________________________________________________________

   316 //

   318 CDiscoverer_SuspendResume_UnitTest* CDiscoverer_SuspendResume_UnitTest::NewL(CDataLogger& aDataLogger,

   319 											MUnitTestObserver& aObserver)

   320 	{

   321 	CDiscoverer_SuspendResume_UnitTest* self =

   322 					new(ELeave) CDiscoverer_SuspendResume_UnitTest(aDataLogger,

   323 																aObserver);

   324 	CleanupStack::PushL(self);

   325 	self->ConstructL();

   326 	CleanupStack::Pop();

   327 	return self;

   328 	}

   330 // Now the Individual transitions need to be added.

   331 inline void CDiscoverer_SuspendResume_UnitTest::ConstructL()

   332 	{

   333 	// Perform the base class initialization

   334 	UnitTestConstructL();

   336 	// Create the Unit test state accessor

   337 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

   338 	// Construct the Unit test context.

   339 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

   340 	// Set up the drive letter for the test (C:)

   341 	iUTContext->iDriveUnit = TDriveUnit(EDriveC);

   342 	// Construct, and store the observer stub

   343 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

   344 	// Add the Transitions in the order they are to run

   345 	// C'tor first, D'tor last...

   346 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

   347 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

   349 	iNotificationValidator = new(ELeave) TDiscoverer_Notification_TransitionValidator(*iUTContext);

   350 	AddTransitionL(new(ELeave)CDiscoverer_Notification_Transition(*iUTContext,*iNotificationValidator));

   352 	iSuspendValidator = new(ELeave) TDiscoverer_Suspend_TransitionValidator(*iUTContext);

   353 	AddTransitionL(new(ELeave)CDiscoverer_Suspend_Transition(*iUTContext,*iSuspendValidator));

   355 	iResumeValidator = new(ELeave) TDiscoverer_Resume_TransitionValidator(*iUTContext);

   356 	AddTransitionL(new(ELeave)CDiscoverer_Resume_Transition(*iUTContext,*iResumeValidator));

   358 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   359 	AddBlockingTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   360 	}

   362 // ______________________________________________________________________________

   363 //

   365 CDiscoverer_ScanDirectory_UnitTest* CDiscoverer_ScanDirectory_UnitTest::NewL(CDataLogger& aDataLogger,

   366 											MUnitTestObserver& aObserver)

   367 	{

   368 	CDiscoverer_ScanDirectory_UnitTest* self =

   369 					new(ELeave) CDiscoverer_ScanDirectory_UnitTest(aDataLogger,

   370 																aObserver);

   371 	CleanupStack::PushL(self);

   372 	self->ConstructL();

   373 	CleanupStack::Pop();

   374 	return self;

   375 	}

   377 // Now the Individual transitions need to be added.

   378 inline void CDiscoverer_ScanDirectory_UnitTest::ConstructL()

   379 	{

   380 	// Perform the base class initialization

   381 	UnitTestConstructL();

   383 	// Create the Unit test state accessor

   384 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

   385 	// Construct the Unit test context.

   386 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

   387 	// Set up the drive letter for the test (C:)

   388 	iUTContext->iDriveUnit = TDriveUnit(EDriveC);

   389 	// Construct, and store the observer stub

   390 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

   391 	// Add the Transitions in the order they are to run

   392 	// C'tor first, D'tor last...

   393 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

   394 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

   395 	iScanDirectoryValidator = new(ELeave) TDiscoverer_ScanDirectory_TransitionValidator(*iUTContext);

   396 	AddTransitionL(new(ELeave)CDiscoverer_ScanDirectoryL_Transition(*iUTContext,*iScanDirectoryValidator));

   397 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   398 	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   399 	}

   401 // ______________________________________________________________________________

   402 //

   404 CDiscoverer_ScanDirectoryCancel_UnitTest* CDiscoverer_ScanDirectoryCancel_UnitTest::NewL(CDataLogger& aDataLogger,

   405 											MUnitTestObserver& aObserver)

   406 	{

   407 	CDiscoverer_ScanDirectoryCancel_UnitTest* self =

   408 					new(ELeave) CDiscoverer_ScanDirectoryCancel_UnitTest(aDataLogger,

   409 																aObserver);

   410 	CleanupStack::PushL(self);

   411 	self->ConstructL();

   412 	CleanupStack::Pop();

   413 	return self;

   414 	}

   416 // Now the Individual transitions need to be added.

   417 inline void CDiscoverer_ScanDirectoryCancel_UnitTest::ConstructL()

   418 	{

   419 	// Perform the base class initialization

   420 	UnitTestConstructL();

   422 	// Create the Unit test state accessor

   423 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

   424 	// Construct the Unit test context.

   425 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

   426 	// Set up the drive letter for the test (C:)

   427 	iUTContext->iDriveUnit = TDriveUnit(EDriveC);

   428 	// Construct, and store the observer stub

   429 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

   430 	// Add the Transitions in the order they are to run

   431 	// C'tor first, D'tor last...

   432 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

   433 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

   434 	iScanDirectoryCancelValidator = new(ELeave) TDiscoverer_ScanDirectoryCancel_TransitionValidator(*iUTContext);

   435 	AddTransitionL(new(ELeave)CDiscoverer_ScanDirectoryCancel_Transition(*iUTContext,*iScanDirectoryCancelValidator));

   436 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   437 	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   438 	}

   440 // ______________________________________________________________________________

   441 //

   443 CDiscoverer_ScanDirectoryIncrement_UnitTest* CDiscoverer_ScanDirectoryIncrement_UnitTest::NewL(CDataLogger& aDataLogger,

   444 											MUnitTestObserver& aObserver)

   445 	{

   446 	CDiscoverer_ScanDirectoryIncrement_UnitTest* self =

   447 					new(ELeave) CDiscoverer_ScanDirectoryIncrement_UnitTest(aDataLogger,

   448 																aObserver);

   449 	CleanupStack::PushL(self);

   450 	self->ConstructL();

   451 	CleanupStack::Pop();

   452 	return self;

   453 	}

   455 // Now the Individual transitions need to be added.

   456 inline void CDiscoverer_ScanDirectoryIncrement_UnitTest::ConstructL()

   457 	{

   458 	// Perform the base class initialization

   459 	UnitTestConstructL();

   461 	// Create the Unit test state accessor

   462 	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;

   463 	// Construct the Unit test context.

   464 	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);

   465 	// Set up the drive letter for the test (C:)

   466 	iUTContext->iDriveUnit = TDriveUnit(EDriveC);

   467 	// Construct, and store the observer stub

   468 	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

   469 	// Add the Transitions in the order they are to run

   470 	// C'tor first, D'tor last...

   471 	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);

   472 	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

   473 	iScanDirectoryIncrementValidator = new(ELeave) TDiscoverer_ScanDirectoryIncrement_TransitionValidator(*iUTContext);

   474 	AddTransitionL(new(ELeave)CDiscoverer_ScanDirectoryIncrementL_Transition(*iUTContext,*iScanDirectoryIncrementValidator));

   475 	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

   476 	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));

   477 	}

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