// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// Implementation of the CDiscoverer Unit Test class methods.
// 
//

#include "DiscovererUnitTest.h"

// ______________________________________________________________________________
//

CDiscoverer_CreateAndDestroy_UnitTest* CDiscoverer_CreateAndDestroy_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_CreateAndDestroy_UnitTest* self = 
					new(ELeave) CDiscoverer_CreateAndDestroy_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	// Chain to the base which calls the ConstructL
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_CreateAndDestroy_UnitTest::ConstructL()
	{
	UnitTestConstructL();
	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	
	// and a validators
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);

	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	//	Examples of C'tor and D'tor transitions on CDiscoverer class. 
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));
	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

void CDiscoverer_CreateAndDestroy_UnitTest::PrepareUnitTestL()
	{
	}

// ______________________________________________________________________________
//

CDiscoverer_MountDrive_UnitTest* CDiscoverer_MountDrive_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_MountDrive_UnitTest* self = 
					new(ELeave) CDiscoverer_MountDrive_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_MountDrive_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Set up the drive letter for the test (C:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveC);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);

	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));
	iMountValidator = new(ELeave) TDiscoverer_MountDriveL_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_MountDriveL_Transition(*iUTContext,*iMountValidator));
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

// ______________________________________________________________________________
//

CDiscoverer_UnmountDrive_UnitTest* CDiscoverer_UnmountDrive_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_UnmountDrive_UnitTest* self = 
					new(ELeave) CDiscoverer_UnmountDrive_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_UnmountDrive_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Set up the drive letter for the test (C:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveC);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));
	iUnmountValidator = new(ELeave) TDiscoverer_UnmountDrive_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_UnmountDrive_Transition(*iUTContext,*iUnmountValidator));
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

// ______________________________________________________________________________
//

CDiscoverer_IsValidEntryL_UnitTest* CDiscoverer_IsValidEntryL_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_IsValidEntryL_UnitTest* self = 
					new(ELeave) CDiscoverer_IsValidEntryL_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_IsValidEntryL_UnitTest::ConstructL()
	{
	_LIT(KDllFileSearchPath,"\\System\\Libs\\Plugins\\*");

	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	// and the path

	// Set up the drive letter for the test (Z:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveZ);
	TDriveName driveName(iUTContext->iDriveUnit.Name());
	iUTContext->iPath.Set(KDllFileSearchPath(), NULL, &driveName);

	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));
	iIsValidEntryValidator = new(ELeave) TDiscoverer_IsValidEntry_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_IsValidEntryL_Transition(*iUTContext,*iIsValidEntryValidator));
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

inline void CDiscoverer_IsValidEntryL_UnitTest::PrepareUnitTestL()
	{
	_LIT(KPathForDiscovery,"Discovery Path = %S");
	iDataLogger.LogInformationWithParameters(KPathForDiscovery,&(iUTContext->iPath.FullName()));
	User::LeaveIfError(iFs.GetDir(iUTContext->iPath.FullName(), KEntryAttMatchExclude | KEntryAttDir, ESortByUid, iUTContext->iDir));
	}

// ______________________________________________________________________________
//

CDiscoverer_ProcessEntryL_UnitTest* CDiscoverer_ProcessEntryL_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_ProcessEntryL_UnitTest* self = 
					new(ELeave) CDiscoverer_ProcessEntryL_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_ProcessEntryL_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Set up the drive letter for the test (C:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveC);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));
	iProcessEntryValidator = new(ELeave) TDiscoverer_ProcessEntryL_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_ProcessEntryL_Transition(*iUTContext,*iProcessEntryValidator));
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

// ______________________________________________________________________________
//

CDiscoverer_CompleteNotificationProcessing_UnitTest* CDiscoverer_CompleteNotificationProcessing_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_CompleteNotificationProcessing_UnitTest* self = 
					new(ELeave) CDiscoverer_CompleteNotificationProcessing_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_CompleteNotificationProcessing_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Set up the drive letter for the test (C:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveC);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

	iCompleteNotificationProcessingValidator = new(ELeave) TDiscoverer_CompleteNotificationProcessing_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_CompleteNotificationProcessing_Transition(*iUTContext,*iCompleteNotificationProcessingValidator));
	
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

// ______________________________________________________________________________
//

CDiscoverer_Notification_UnitTest* CDiscoverer_Notification_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_Notification_UnitTest* self = 
					new(ELeave) CDiscoverer_Notification_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_Notification_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Set up the drive letter for the test (C:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveC);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));

	iNotificationValidator = new(ELeave) TDiscoverer_Notification_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Notification_Transition(*iUTContext,*iNotificationValidator));
	
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddBlockingTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}
// ______________________________________________________________________________
//

CDiscoverer_SuspendResume_UnitTest* CDiscoverer_SuspendResume_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_SuspendResume_UnitTest* self = 
					new(ELeave) CDiscoverer_SuspendResume_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_SuspendResume_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Set up the drive letter for the test (C:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveC);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));
	
	iNotificationValidator = new(ELeave) TDiscoverer_Notification_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Notification_Transition(*iUTContext,*iNotificationValidator));

	iSuspendValidator = new(ELeave) TDiscoverer_Suspend_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Suspend_Transition(*iUTContext,*iSuspendValidator));
	
	iResumeValidator = new(ELeave) TDiscoverer_Resume_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Resume_Transition(*iUTContext,*iResumeValidator));

	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddBlockingTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

// ______________________________________________________________________________
//

CDiscoverer_ScanDirectory_UnitTest* CDiscoverer_ScanDirectory_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_ScanDirectory_UnitTest* self = 
					new(ELeave) CDiscoverer_ScanDirectory_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_ScanDirectory_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Set up the drive letter for the test (C:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveC);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));
	iScanDirectoryValidator = new(ELeave) TDiscoverer_ScanDirectory_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_ScanDirectoryL_Transition(*iUTContext,*iScanDirectoryValidator));
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

// ______________________________________________________________________________
//

CDiscoverer_ScanDirectoryCancel_UnitTest* CDiscoverer_ScanDirectoryCancel_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_ScanDirectoryCancel_UnitTest* self = 
					new(ELeave) CDiscoverer_ScanDirectoryCancel_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_ScanDirectoryCancel_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Set up the drive letter for the test (C:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveC);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));
	iScanDirectoryCancelValidator = new(ELeave) TDiscoverer_ScanDirectoryCancel_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_ScanDirectoryCancel_Transition(*iUTContext,*iScanDirectoryCancelValidator));
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}

// ______________________________________________________________________________
//

CDiscoverer_ScanDirectoryIncrement_UnitTest* CDiscoverer_ScanDirectoryIncrement_UnitTest::NewL(CDataLogger& aDataLogger,
											MUnitTestObserver& aObserver)
	{
	CDiscoverer_ScanDirectoryIncrement_UnitTest* self = 
					new(ELeave) CDiscoverer_ScanDirectoryIncrement_UnitTest(aDataLogger,
																aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self; 
	}

// Now the Individual transitions need to be added.
inline void CDiscoverer_ScanDirectoryIncrement_UnitTest::ConstructL()
	{
	// Perform the base class initialization
	UnitTestConstructL();

	// Create the Unit test state accessor
	iStateAccessor = new(ELeave) TDiscoverer_StateAccessor;
	// Construct the Unit test context.
	iUTContext = new(ELeave) CDiscoverer_UnitTestContext(iDataLogger, *iStateAccessor, *this, iFs);
	// Set up the drive letter for the test (C:)
	iUTContext->iDriveUnit = TDriveUnit(EDriveC);
	// Construct, and store the observer stub
	iUTContext->iDiscovererObserver = CObserverStub::NewL(*this,*iUTContext);
	// Add the Transitions in the order they are to run
	// C'tor first, D'tor last...
	iCtorValidator = new(ELeave) TDiscoverer_Ctor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_NewL_Transition(*iUTContext,*iCtorValidator));
	iScanDirectoryIncrementValidator = new(ELeave) TDiscoverer_ScanDirectoryIncrement_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_ScanDirectoryIncrementL_Transition(*iUTContext,*iScanDirectoryIncrementValidator));
	iDtorValidator = new(ELeave) TDiscoverer_Dtor_TransitionValidator(*iUTContext);
	AddTransitionL(new(ELeave)CDiscoverer_Dtor_Transition(*iUTContext,*iDtorValidator));
	}