// Copyright (c) 2004-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:
// This file contains test classes and their implementations
// to test production class CRegistrar. Where necessary stubs
// are implemented to help in writing test harness using RTest.
//
//
#include "RegistryData.h"
#include "EComErrorCodes.h"
#include "EComUidCodes.h"
#include "ImplementationInformation.h"
#include "RegistryData.h"
#include "Registrar.h"
#include "RegistrarObserver.h"
#include "../EcomTestUtils/EcomTestUtils.h"
#include "EComEntryBase.h"
#include "DriveInfo.h"
#include <e32test.h>
#include <f32file.h>
#include <bautils.h>
#include <startup.hrh>
#include "baspi.h"
_LIT (KDataDir, "C:\\private\\10009D8F\\ECom*");
//We need two different entry RSC and the SPI to fully test CRegistrar
//------------------------------NEW TYPE----------------------------------------
const TUid NewDllUid={0x101F847B};
_LIT(KNewResourceFileNameOnly,"EComExample5.rsc");
_LIT(KNewResourceFileNameC, "C:\\resource\\plugins\\EComExample5.rsc");
_LIT(KNewDllFileNameC, "C:\\sys\\bin\\EComExample5.dll");
_LIT(KNewResourceFileNameZ, "z:\\RAMOnly\\EComExample5.rsc");
_LIT(KNewDllFileNameZ,"z:\\RAMOnly\\EComExample5.dll");
//We need IIC type 3 RSC to fully test CRegistrar
//------------------------------IIC TYPE 3----------------------------------------
const TUid Type3DllUid = {0x10009E3E};
_LIT(KType3ResourceFileNameOnly,"EComExample12.rsc");
_LIT(KType3ResourceFileNameC, "C:\\resource\\plugins\\EComExample12.rsc");
_LIT(KType3DllFileNameC, "C:\\sys\\bin\\EComExample12.dll");
_LIT(KType3ResourceFileNameZ, "z:\\RAMOnly\\EComExample12.rsc");
_LIT(KType3DllFileNameZ,"z:\\RAMOnly\\EComExample12.dll");
//We need IIC type 3 RSC with data exceed maximum to fully test CRegistrar
//------------------------------IIC TYPE 3----------------------------------------
_LIT(KType3BadDataResourceFileNameOnly,"EComExampleBadData.rsc");
_LIT(KType3BadDataResourceFileNameC, "C:\\resource\\plugins\\EComExampleBadData.rsc");
_LIT(KType3BadDataDllFileNameC, "C:\\sys\\bin\\EComExampleBadData.dll");
_LIT(KType3BadDataResourceFileNameZ, "z:\\RAMOnly\\EComExampleBadData.rsc");
_LIT(KType3BadDataDllFileNameZ,"z:\\RAMOnly\\EComExampleBadData.dll");
_LIT(KType3BadData1ResourceFileNameOnly,"EComExampleBadData1.rsc");
_LIT(KType3BadData1ResourceFileNameC, "C:\\resource\\plugins\\EComExampleBadData1.rsc");
_LIT(KType3BadData1DllFileNameC, "C:\\sys\\bin\\EComExampleBadData1.dll");
_LIT(KType3BadData1ResourceFileNameZ, "z:\\RAMOnly\\EComExampleBadData1.rsc");
_LIT(KType3BadData1DllFileNameZ,"z:\\RAMOnly\\EComExampleBadData1.dll");
_LIT(KType3BadData2ResourceFileNameOnly,"EComExampleBadData2.rsc");
_LIT(KType3BadData2ResourceFileNameC, "C:\\resource\\plugins\\EComExampleBadData2.rsc");
_LIT(KType3BadData2DllFileNameC, "C:\\sys\\bin\\EComExampleBadData2.dll");
_LIT(KType3BadData2ResourceFileNameZ, "z:\\RAMOnly\\EComExampleBadData2.rsc");
_LIT(KType3BadData2DllFileNameZ,"z:\\RAMOnly\\EComExampleBadData2.dll");
//We need IIC type 2 RSC to fully test CRegistrar
//------------------------------IIC TYPE 2----------------------------------------
_LIT(KType2ResourceFileNameOnly,"EComExample14.rsc");
_LIT(KType2ResourceFileNameC, "C:\\resource\\plugins\\EComExample14.rsc");
_LIT(KType2DllFileNameC, "C:\\sys\\bin\\EComExample14.dll");
_LIT(KType2ResourceFileNameZ, "z:\\RAMOnly\\EComExample14.rsc");
_LIT(KType2DllFileNameZ,"z:\\RAMOnly\\EComExample14.dll");
//------------------------------LEGACY TYPE-------------------------------------
// spi test file
_LIT(KEComSpiTestFilePathAndName, "Z:\\Test\\Data\\EcomTest.spi");
// spi test file for testing IIC Type3
_LIT(KEComSpiTestFileType3PathAndName, "Z:\\Test\\Data\\ecomtesttype3.spi");
const TInt KOneSecond = 1000000;
const TUid interfaceUidExample12 = {0x10009E36};
const TUid extendedInterfaceUid1 = {0x10009E44};
const TUid extendedInterfaceUid2 = {0x10009E45};
const TUid extendedInterfaceUid3 = {0x10009E46};
LOCAL_D RTest test(_L("t_Registrar.exe"));
LOCAL_D RFs TheFs;
LOCAL_D CTrapCleanup* TheTrapCleanup = NULL;
LOCAL_D CActiveScheduler* TheActiveScheduler = NULL;
// Used for supressing warning in OOM tests
#define __UNUSED_VAR(var) var = var
//It is used by some test methods which are called two times:
//from normal test and from OOM test.
static void LeaveIfErrNoMemory(TInt aError)
{
if(aError == KErrNoMemory)
{
User::Leave(aError);
}
}
/**
TRegistrar_StateAccessor class allows access to private and protected
members of production code class CRegistrar, as its a friend class.
*/
class TRegistrar_StateAccessor
{
public:
void DiscoveriesBegin(CRegistrar& aRegistrar);
void DiscoveriesComplete(CRegistrar& aRegistrar, TBool aSuccessful);
void DriveRemovedL(CRegistrar& aRegistrar, TDriveUnit aDriveUnit);
void DriveReinstatedL(CRegistrar& aRegistrar, TDriveUnit aDriveUnit);
void RegisterDiscoveryL(CRegistrar& aRegistrar,const TDriveName& aDrive, CPluginBase*& aEntry,TBool aDatFileExists);
void ParseL(CRegistrar& aRegistrar,
CPluginBase*& aEntry,
CRegistryData::CDllData& aDll);
void ParseRegistrationDataL(CRegistrar& aRegistrar,
CPluginBase*& aEntry,
TDriveUnit& aDriveUnit,
TBool aUpdate,
TInt aRegistryDriveIndex,
CRegistryData::CDriveData* aDriveData);
CRegistrar::TRegistrarState State(CRegistrar& aRegistrar);
};
/**
Parses the resource file associated with an
Interface Implementation Collection for the plugin entry.
@param aRegistrar The CRegistrar class object under test
@param aEntry an ecom entry discovered
@param aDll CRegistrar::CDllData object in which parsed data needs to be stored
@pre CRegistrar should be fully constructed.
@post The resource file is parsed and the data is added to 'aDll'.
*/
void TRegistrar_StateAccessor::ParseL(CRegistrar& aRegistrar,
CPluginBase*& aEntry,
CRegistryData::CDllData& aDll)
{
aRegistrar.ParseL(aEntry,aDll);
}
/**
Determines if the directory entry for an Interface Implementation
Collection requires registration. Parses and registers the plugin entry
associated with the resource file if entry is not already registered.
@param aRegistrar The CRegistrar class object under test
@param aEntry Directory entry for the Interface Impplementation Collection.
@param aRscFileName Resource file from which to extract the data
@param aDrive Drive on which registry data has been found on
@param aUpdate Flag indicating if this is an update, or new entry.
@param aRegistryDriveIndex Index within the registry data
for the branch that the registry entry was found within.
@pre CRegistrar is fully constructed.
@post The Interface Implementation Collection entry has been processed appropriately.
*/
void TRegistrar_StateAccessor::ParseRegistrationDataL(CRegistrar& aRegistrar,
CPluginBase*& aEntry,
TDriveUnit& aDrive,
TBool aUpdate,
TInt aRegistryDriveIndex,
CRegistryData::CDriveData* aDriveData)
{
aRegistrar.ParseRegistrationDataL(aEntry, aDrive,aUpdate, aRegistryDriveIndex, aDriveData);
}
/**
Overload of the MDiscovererObserver callback method.
The cue that a registry update is about to occur.
@param aRegistrar The CRegistrar class object under test
@pre CRegistrar is fully constructed
@post The Registry data manager has been informed that its internal
data is out of date.
*/
void TRegistrar_StateAccessor::DiscoveriesBegin(CRegistrar& aRegistrar)
{
aRegistrar.DiscoveriesBegin();
}
/**
Overload of the MDiscovererObserver callback method.
The cue that a registry update is done.
@param aRegistrar The CRegistrar class object under test
@param aSuccessful The registry data has been updated successfully
@pre CRegistrar is fully constructed
@post The current registry data and the internal access indexes have been rebuilt.
*/
void TRegistrar_StateAccessor::DiscoveriesComplete(CRegistrar& aRegistrar,
TBool aSuccessful)
{
aRegistrar.DiscoveriesComplete(aSuccessful, EPluginProcessingTypeAll);
}
/**
Overload of the MDiscovererObserver callback method.
Signals registry that the registered Interface Implementation
Collections stored upon the specified drive are no
longer available for use.
@param aRegistrar The CRegistrar class object under test
@param aDrive The drive identifier.
@pre CRegistrar is fully constructed.
@post The registered Interface Implementation Collections
stored upon the specified drive are no
longer available for use.
*/
void TRegistrar_StateAccessor::DriveRemovedL(CRegistrar& aRegistrar,
TDriveUnit aDrive)
{
aRegistrar.DriveRemovedL(aDrive);
}
/**
Overload of the MDiscovererObserver callback method.
Signals registry that the registered Interface
Implementation Collections stored upon the specified drive are again
available for use.
@param aRegistrar The CRegistrar class object under test
@param aDrive The drive identifier.
@pre CRegistrar is fully constructed.
@post The registered Interface Implementation Collections
stored upon the specified drive are again
made available for use.
*/
void TRegistrar_StateAccessor::DriveReinstatedL(CRegistrar& aRegistrar,
TDriveUnit aDrive)
{
aRegistrar.DriveReinstatedL(aDrive);
}
/**
Overload of the MDiscovererObserver callback method.
Adds the specified Interface Implementation Collection Entry to the registry.
@param aRegistrar The CRegistrar class object under test
@param aDirEntry The plugin entry to register.
@pre CRegistrar is fully constructed
@post The plugin entry is registered.
*/
void TRegistrar_StateAccessor::RegisterDiscoveryL(CRegistrar& aRegistrar,
const TDriveName& aDrive,
CPluginBase*& aEntry,
TBool aDatFileExists )
{
aRegistrar.RegisterDiscoveryL(aDrive,aEntry,aDatFileExists);
}
/**
Retrieves the object's current state.
@return TCRegistarState the CRegistrar's current state.
@pre CRegistrar is fully constructed.
@post the CRegistrar's current state has been returned.
*/
CRegistrar::TRegistrarState TRegistrar_StateAccessor::State(CRegistrar& aRegistrar)
{
return aRegistrar.State();
}
/**
TRegistryData_StateAccessor class allows access to private and protected
members of production code class CRegistryData, as its a friend class.
*/
class TRegistryData_StateAccessor
{
public:
TInt FindImplementation(CRegistryData& aRegistryData,
const TUid aImplUid,
const TUid aInterfaceUid,
CRegistryData::CImplementationData*& aImplData) const;
};
/**
@return KErrNone if found otherwise KErrNotFound
@param aRegistryData The CRegistryData class object
@param aImplUid The implementation to find.
@param aInterfaceUid If greater than 0 the interface associated with the
implementation to find.
@param aImplData The found implementation data.
@pre CRegistrar is fully constructed
*/
TInt TRegistryData_StateAccessor::FindImplementation(CRegistryData& aRegistryData,
const TUid aImplUid,
const TUid aInterfaceUid,
CRegistryData::CImplementationData*& aImplData) const
{
return aRegistryData.FindImplementation(aImplUid, aInterfaceUid, aImplData);
}
/**
The implementation of the abstract Registrar Observer class,
used for recieving notifications of registry changes.
Stub class(for CEComServer) used for the creation of CRegistrar class object.
CEComServer class acts as observer for CRegistrar.
*/
class CTestRegistrarObserver : public MRegistrarObserver // codescanner::missingcclass
{
public:
// This function is used by RegistrarObserver (i.e.CEComServer) to notify its
// clients(REComSession objects) that some change has happened in Registry.
// Here we have no clients to notify, so no implementaion.
void Notification( TInt /*aNotification*/ ) {}
};
/**
Test class for object CRegistrar.
This class provides the parameters and behaviour that
allows this class to behave normally under a test
scenario.
*/
class CRegistrarTest : public CBase
{
public:
static CRegistrarTest* NewL(TBool aIsFullDiscovery);
virtual ~CRegistrarTest();
const CImplementationInformation * GetImplementationDataL();
void EnableDisableTestL();
void ResumeSuspendTestL();
void DiscoveriesBegin_Register_CompleteTestL();
void DriveRemovedReinstatedTestL();
void ParseTestL();
void ParseType2TestL();
void ParseType3TestL();
void ParseType3BadDataTestL();
void ParseRegistrationDataTestL();
void ParseRegistrationDataType3TestL();
void StateTransitionTestL();
void ParseSpiRegistrationDataTestL();
void ParseSpiRegistrationDataType3TestL();
void ParseSpiTestL();
void ParseSpiType3TestL();
private:
CRegistrarTest();
void ConstructL(TBool aIsFullDiscovery);
void ParseBadDataTestL(const TDesC& aRscFullName, const TDesC& aRscNameOnly);
public:
/** The instance of the class under test */
CRegistrar* iRegistrar;
/** The instance of the State Accessor class */
TRegistrar_StateAccessor* iStateAccessor;
/** The registry data instance required to construct a CRegistrar object */
CRegistryData* iRegistryData;
/** The instance of the Registry Data State Accessor class */
TRegistryData_StateAccessor* iRegistryDataStateAccessor;
/** The instance of the observer of CRegistrar class */
MRegistrarObserver* iRegistrarObserver;
/** The destination for the data discovered during a parse */
CRegistryData::CDllData* iDllData;
/** Unique Id of the ECOM dll */
TUid iDllUid;
/** Unique Id of an interface implementation */
TUid iImplementationUid;
/** Unique Id of an interface */
TUid iInterfaceUid;
/** The drive on which interface implementations can be found */
TDriveUnit iDriveUnit;
/** Ecom plugin which contains interface implementations. Used in Registration APIs.*/
TEntry iDllEntry;
};
/**
Standardised safe construction which
leaves nothing on the cleanup stack.
@param aIsFullDiscovery whether the constructor make full discovery
@post CRegistrarTest is fully constructed and initialised.
*/
CRegistrarTest* CRegistrarTest::NewL(TBool aIsFullDiscovery)
{
CRegistrarTest* self = new (ELeave) CRegistrarTest();
CleanupStack::PushL(self);
self->ConstructL(aIsFullDiscovery);
CleanupStack::Pop(self);
return self;
}
/**
Standardized default c'tor
@post CRegistrarTest is fully constructed.
*/
CRegistrarTest::CRegistrarTest()
: CBase(),
iDriveUnit(EDriveC)
{
iDllUid.iUid = 0x101F847B; // Dlluid for Ecom plugin EComExample5.dll
iInterfaceUid.iUid = 0x10009DC0; // Interface uid for interface contained in above plugin
iImplementationUid.iUid = 0x101f847C; // Implementaion uid for above interface
TUid uid1 = {0};
TUid uid2 = {0};
iDllEntry.iType = TUidType(uid1, uid2, iDllUid);//Setting Dlluid to plugin entry
}
/**
Destructor.
@post This object is properly destroyed.
*/
CRegistrarTest::~CRegistrarTest()
{
delete iDllData;
delete iRegistrar;
delete iRegistryData;
delete iRegistrarObserver;
delete iStateAccessor;
delete iRegistryDataStateAccessor;
}
/**
Standardized 2nd(Initialization) phase of two phase construction.
@param aIsFullDiscovery whether the constructor make full discovery
@post CRegistrarTest is fully constructed.
*/
void CRegistrarTest::ConstructL(TBool aIsFullDiscovery)
{
CRegistryData::CDriveData* driveData=NULL;
iRegistrarObserver = new (ELeave) CTestRegistrarObserver;
iStateAccessor = new (ELeave) TRegistrar_StateAccessor;
iRegistryDataStateAccessor = new (ELeave) TRegistryData_StateAccessor;
iRegistryData = CRegistryData::NewL(TheFs);
iRegistrar = CRegistrar::NewL(*iRegistryData, *iRegistrarObserver, TheFs);
if(aIsFullDiscovery)
{
iRegistrar->ProcessSSAEventL(EStartupStateNonCritical);
}
iDllData = CRegistryData::CDllData::NewLC(driveData);
CleanupStack::Pop(iDllData);
}
/**
Returns information of a particular interface implementation.
@return Information on the requested implementation
@pre This object is fully constructed
*/
const CImplementationInformation * CRegistrarTest::GetImplementationDataL()
{
CRegistryData::CImplementationData *implementationData=NULL;
TUid dummyUid;
dummyUid.iUid = 0;
User::LeaveIfError(iRegistryDataStateAccessor->FindImplementation(*iRegistryData, iImplementationUid,
dummyUid, implementationData));
return implementationData->iImplInfo;
}
/**
The test executes by first Disabling the Implementation then by
Enabling it.
@SYMTestCaseID SYSLIB-ECOM-CT-0727
@SYMTestCaseDesc Tests for enabling and disabling the Implementation
@SYMTestPriority High
@SYMTestActions Fetch the Implementation information for testing for iImplementationUid
Disable and enable the implementation for the unique UID
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ0000
*/
void CRegistrarTest::EnableDisableTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0727 "));
const CImplementationInformation *implimentationInfo = NULL;
// Get the Implementation information for testing for iImplementationUid.
// Implementation for iImplementationUid should be registered to
// run this test successfully.
TRAPD(err, implimentationInfo = GetImplementationDataL());
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
test(implimentationInfo != NULL);
// Disable the implementaion
err = iRegistrar->Disable(iImplementationUid);
::LeaveIfErrNoMemory(err);
test(KErrNone == err);
test(implimentationInfo->Disabled());//It should be disabled
// Enable the implementaion
err = iRegistrar->Enable(iImplementationUid);
::LeaveIfErrNoMemory(err);
test(KErrNone == err);
test(!implimentationInfo->Disabled());//It should be enabled
}
/**
The test executes by first suspending the discoverer then by resuming it.
@SYMTestCaseID SYSLIB-ECOM-CT-0728
@SYMTestCaseDesc Tests for overloaded MBackupNotifierObserver's Suspend and Resume functions
@SYMTestPriority High
@SYMTestActions The test executes by first calling CRegistrar's suspend and then by resume.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ0000
*/
void CRegistrarTest::ResumeSuspendTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0728 "));
TInt err = iRegistrar->Suspend();
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
err = iRegistrar->Resume();
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
}
/**
The test executes by calling DiscoveriesBegin, RegisterDiscoveryL and
DiscoveriesComplete in sequence to register the plugin.
@SYMTestCaseID SYSLIB-ECOM-CT-0729
@SYMTestCaseDesc Tests for registering the DLL interfaces
@SYMTestPriority High
@SYMTestActions Calls up DiscoveriesBegin, RegisterDiscoveryL and
DiscoveriesComplete in sequence to register the plugin and
verifies that DLL's have been registered succesfully.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ0000
*/
void CRegistrarTest::DiscoveriesBegin_Register_CompleteTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0729 "));
// The following three steps need to be executed to successfully
// register the plugin
iStateAccessor->DiscoveriesBegin(*iRegistrar);
//-----------------REGISTRATION PART------------------------------------
CPluginBase* entryBase=NULL;
TInt err=KErrNone;
TBool update = EFalse;
TInt driveIndex = KErrNotFound; //Used as return parameter used below
TBool isDriveRegistered = EFalse; //Used as return parameter used below
CRegistryData::CDriveData* driveData = NULL;
//Testing a RSc based entry using EComExample5.dll and EComExample5.rsc
TEntry rscBasedEntry;
rscBasedEntry.iName=KNewResourceFileNameOnly;
err = TheFs.Modified(KNewResourceFileNameC, rscBasedEntry.iModified);
test(err==KErrNone);
TParse rscPath;
rscPath.Set(KNewResourceFileNameC,NULL,NULL);
entryBase=CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);
CleanupStack::PushL(entryBase);
//Now register this Rsc Entry with the registrar
TRAP(err, iStateAccessor->RegisterDiscoveryL(*iRegistrar,rscPath.Drive(), entryBase,ETrue));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
CleanupStack::PopAndDestroy(entryBase);
entryBase=NULL;
TRAP(err, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));
::LeaveIfErrNoMemory(err);
test(driveIndex != KErrNotFound);
//Verify weather dll interfaces got registered
// Check whether Rsc based entry is already registered in CRegistryData
TRAP(err, isDriveRegistered = iRegistryData->IsRegisteredWithDate(
NewDllUid,
rscBasedEntry.iModified,
update,
driveData));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
test(isDriveRegistered);
test(!update);// As plugin is just registered, it does not require update.
//THE REASON WHY THIS FUNCTION IS MOVED TO THE BACK AS IT PREVENT THE TESTING
//OF THE LEGACY PLUGINS BEING REGISTERED AS DURING THE VALIDATE REGISTRY
//THE LEGACY ENTRY WILL BE WIPED OUT
iStateAccessor->DiscoveriesComplete(*iRegistrar, EFalse);
test(iRegistrar != NULL);
}
/**
@SYMTestCaseID SYSLIB-ECOM-CT-0730
@SYMTestCaseDesc Tests for CRegistrar::DriveRemovedL,DriveReinstatedL functions
@SYMTestPriority High
@SYMTestActions The test executes by first making the test drive uninstall and
then testing for Install and Uninstall.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ0000
*/
void CRegistrarTest::DriveRemovedReinstatedTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0730 "));
// We are checking with F Drive.
// The test executes by first removing and then reinstalling
const TTime modified(0); //Dummy parameter...
TBool update = EFalse; //Dummy parameter...
TBool isDriveRegistered = EFalse;
TInt driveIndex = KErrNotFound;
CRegistryData::CDriveData* driveData = NULL;
iDriveUnit = EDriveF;
TInt error = KErrNone;
TRAP(error, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));
::LeaveIfErrNoMemory(error);
TInt err = KErrNone;
if(driveIndex != KErrNotFound)
{
TRAP(err, iRegistryData->IsRegisteredWithDate(
iDllUid,
modified,
update,
driveData));
::LeaveIfErrNoMemory(err);
}
isDriveRegistered = (driveIndex != KErrNotFound);
//Remove the drive from registry if registered
if(isDriveRegistered)
{
TRAP(err, iStateAccessor->DriveRemovedL( *iRegistrar, iDriveUnit));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
//Call CRegistryData::IsRegisteredWithDate again to check its removed now
driveIndex = KErrNotFound;
TRAP(err, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));
//Drive should not be present
::LeaveIfErrNoMemory(err);
test(driveIndex == KErrNotFound);
}
// Install the drive in registry
TRAP(err, iStateAccessor->DriveReinstatedL(*iRegistrar, iDriveUnit));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
//Call CRegistryData::IsRegisteredWithDate to check its Reinstalled now
driveIndex = KErrNotFound;
TRAP(err, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));
::LeaveIfErrNoMemory(err);
//Drive should be present now
test(driveIndex != KErrNotFound);
TRAP(err, iRegistryData->IsRegisteredWithDate(
iDllUid,
modified,
update,
driveData));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
//Remove the drive from registry if it was not registered before
if(!isDriveRegistered)
{
TRAP(err, iStateAccessor->DriveRemovedL( *iRegistrar, iDriveUnit));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
//Call CRegistryData::IsRegisteredWithDate again to check its removed now
driveIndex = KErrNotFound;
TRAP(err, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));
//Drive should not be present
::LeaveIfErrNoMemory(err);
test(driveIndex == KErrNotFound);
}
}
/**
The test executes by parsing the Interface implementaion information
from the given resource file.
@SYMTestCaseID SYSLIB-ECOM-CT-0731
@SYMTestCaseDesc Tests for verification of Interface implementaion information
@SYMTestPriority High
@SYMTestActions Parse the resource information associated with an
Interface Implementation Collection for entry into the registry
information.Check for OOM error or parse error.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ0000
*/
void CRegistrarTest::ParseTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0731 "));
TInt error=KErrNone;
CPluginBase* entryBase=NULL;
CRegistryData::CDllData* dllData=NULL;
CRegistryData::CInterfaceData* ifData =NULL;
CRegistryData::CDriveData* driveData = NULL;
//Testing a RSC based entry using EComExample5.dll and EComExample5.rsc
//(101F847B.RSS)
TEntry rscBasedEntry;
rscBasedEntry.iName=KNewResourceFileNameOnly;
error = TheFs.Modified(KNewResourceFileNameC, rscBasedEntry.iModified);
test(error==KErrNone);
TParse rscPath;
rscPath.Set(KNewResourceFileNameC,NULL,NULL);
TDriveUnit driveUnit(rscPath.Drive());
error=iRegistryData->FindDriveL(driveUnit,driveData);
test(error!=KErrNotFound);
entryBase=CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);
CleanupStack::PushL(entryBase);
dllData=CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);
//Now testing the parseL function
TRAP(error, iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));
::LeaveIfErrNoMemory(error);
test(error == KErrNone);
//Now checking the content of the DllData
test(dllData->iIfList->Count()==1);
ifData=(*(dllData->iIfList))[0];
test(ifData->iInterfaceUid.iUid==0x10009DC0);
test(ifData->iImplementations->Count()==1);
CleanupStack::PopAndDestroy(dllData);
CleanupStack::PopAndDestroy(entryBase);
entryBase=NULL;
dllData=NULL;
ifData=NULL;
}
/**
The test executes by parsing the Interface implementation information with type 2 entries
from the given resource file.
@SYMTestCaseID SYSLIB-ECOM-UT-3563
@SYMTestCaseDesc Tests for verification of Interface implementation information with type 2 entries
@SYMTestPriority High
@SYMTestActions Parse the resource information associated with an
Interface Implementation Collection type 2 for entry into the registry
information.Check for OOM error or parse error.
@SYMTestExpectedResults CRegistrar::ParseL() function parses resource file without error.
Data is interpreted correctly.
@SYMEC EC43
*/
void CRegistrarTest::ParseType2TestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3563 "));
TInt error = KErrNone;
CPluginBase* entryBase = NULL;
CRegistryData::CDllData* dllData = NULL;
CRegistryData::CInterfaceData* ifData = NULL;
CRegistryData::CDriveData* driveData = NULL;
TUid interfaceUidExample14 = {0x10009E36};
//Tests an RSC based entry using EComExample14.dll and EComExample14.rsc
//(EcomExample14.RSS)
TEntry rscBasedEntry;
rscBasedEntry.iName = KType2ResourceFileNameOnly;
error = TheFs.Modified(KType2ResourceFileNameC, rscBasedEntry.iModified);
test(error == KErrNone);
TParse rscPath;
rscPath.Set(KType2ResourceFileNameC,NULL,NULL);
TDriveUnit driveUnit(rscPath.Drive());
error = iRegistryData->FindDriveL(driveUnit,driveData);
test(error != KErrNotFound);
entryBase = CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);
CleanupStack::PushL(entryBase);
dllData = CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);
//tests the parseL function
TRAP(error, iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));
::LeaveIfErrNoMemory(error);
test(error == KErrNone);
//checks the content of the DllData
test(dllData->iIfList->Count() == 1);
ifData = (*(dllData->iIfList))[0];
test(ifData->iInterfaceUid == interfaceUidExample14);
CleanupStack::PopAndDestroy(dllData);
CleanupStack::PopAndDestroy(entryBase);
}
/**
The test executes by parsing the Interface implementation information with type 3 entries
from the given resource file.
@SYMTestCaseID SYSLIB-ECOM-UT-3564
@SYMTestCaseDesc Tests for verification of Interface implementation information with type 3 entries
@SYMTestPriority High
@SYMTestActions Parse the resource information associated with an
Interface Implementation Collection type 3 for entry into the registry
information.Check for OOM error or parse error.
@SYMTestExpectedResults CRegistrar::ParseL() function parses resource file without error.
Data is interpreted correctly.
@SYMEC EC43
*/
void CRegistrarTest::ParseType3TestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3564 "));
TInt error = KErrNone;
CPluginBase* entryBase = NULL;
CRegistryData::CDllData* dllData = NULL;
CRegistryData::CInterfaceData* ifData = NULL;
CRegistryData::CDriveData* driveData = NULL;
CRegistryData::CImplementationData* implData = NULL;
CImplementationInformation* implInfo = NULL;
//Tests an RSC based entry using EComExample12.dll and EComExample12.rsc
//(EcomExample12.RSS)
TEntry rscBasedEntry;
rscBasedEntry.iName = KType3ResourceFileNameOnly;
error = TheFs.Modified(KType3ResourceFileNameC, rscBasedEntry.iModified);
test(error == KErrNone);
TParse rscPath;
rscPath.Set(KType3ResourceFileNameC,NULL,NULL);
TDriveUnit driveUnit(rscPath.Drive());
error = iRegistryData->FindDriveL(driveUnit,driveData);
test(error != KErrNotFound);
entryBase = CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);
CleanupStack::PushL(entryBase);
dllData = CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);
// Tests the parseL function
TRAP(error, iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));
::LeaveIfErrNoMemory(error);
test(error == KErrNone);
// Checks the content of the DllData
test(dllData->iIfList->Count() == 1);
ifData = (*(dllData->iIfList))[0];
test(ifData->iInterfaceUid == interfaceUidExample12);
//Currently there are 3 implementations for this interface.
//But the implementation(UID=0x10009E3D) is ROM-only but is actually in RAM will not be created.
//So, actually number of implementations created for this interface is 2.
test(ifData->iImplementations->Count() == 2);
implData = (*(ifData->iImplementations))[0];
implInfo = implData->iImplInfo;
// Fetches the list of extended interfaces for the first implementation
RArray<TUid>* extendedInterfaceList = implInfo->GetExtendedInterfaceList();
test(extendedInterfaceList->Count()==3);
test((*extendedInterfaceList)[0] == extendedInterfaceUid1);
test((*extendedInterfaceList)[1] == extendedInterfaceUid2);
test((*extendedInterfaceList)[2] == extendedInterfaceUid3);
CleanupStack::PopAndDestroy(dllData);
CleanupStack::PopAndDestroy(entryBase);
}
/** Wrapper function for testing ParseL function with type 3 entries
and data in the resource file exceed maximum
*/
void CRegistrarTest::ParseBadDataTestL(const TDesC& aRscFullName, const TDesC& aRscNameOnly)
{
TInt error = KErrNone;
CPluginBase* entryBase = NULL;
CRegistryData::CDllData* dllData = NULL;
CRegistryData::CDriveData* driveData = NULL;
TEntry rscBasedEntry;
rscBasedEntry.iName = aRscNameOnly;
error = TheFs.Modified(aRscFullName, rscBasedEntry.iModified);
test(error == KErrNone);
TParse rscPath;
rscPath.Set(aRscFullName,NULL,NULL);
TDriveUnit driveUnit(rscPath.Drive());
error = iRegistryData->FindDriveL(driveUnit,driveData);
test(error != KErrNotFound);
entryBase = CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), ETrue);
CleanupStack::PushL(entryBase);
dllData = CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);
//Tests the parseL function
TRAP(error, iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));
test(error == KErrNotSupported);
CleanupStack::PopAndDestroy(dllData);
CleanupStack::PopAndDestroy(entryBase);
}
/**
@SYMTestCaseID SYSLIB-ECOM-UT-3565
@SYMTestCaseDesc Tests for verification of Interface implementation information with type 3 entries
and data in the resource file exceed maximum.
@SYMTestPriority High
@SYMTestActions Parse the resource information associated with an
Interface Implementation Collection type 3 for entry into the registry
information.
@SYMTestExpectedResults CRegistrar::ParseL() function parses resource file with KErrNotSupported leave occurs.
@SYMEC EC43
@SYMDEF DEF111196
*/
void CRegistrarTest::ParseType3BadDataTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3565 "));
// Tests for number of strings of default data exceeds maximum
// Uses EComExampleBadData.dll and EComExampleBadData.rsc (EcomExampleBadData.RSS)
ParseBadDataTestL(KType3BadDataResourceFileNameC,KType3BadDataResourceFileNameOnly);
// Tests for number of interfaces exceeds maximum
// Uses EComExampleBadData1.dll and EComExampleBadData1.rsc (EcomExampleBadData1.RSS)
ParseBadDataTestL(KType3BadData1ResourceFileNameC,KType3BadData1ResourceFileNameOnly);
// Tests for number of implementation in one interfaces exceeds maximum
// Uses EComExampleBadData2.dll and EComExampleBadData2.rsc (EcomExampleBadData2.RSS)
ParseBadDataTestL(KType3BadData2ResourceFileNameC,KType3BadData2ResourceFileNameOnly);
}
/**
@SYMTestCaseID SYSLIB-ECOM-CT-0089
@SYMTestCaseDesc Check that the ParseL for spi data works correctly.
@SYMTestPriority High
@SYMTestActions Ensure ecomtest.spi can be parsed successfully
and no leave occurs.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ3655
*/
void CRegistrarTest::ParseSpiTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0089 "));
TEntry spiEntry;
TParse spiPath;
if (TheFs.Entry(KEComSpiTestFilePathAndName, spiEntry) != KErrNone)
return;
spiPath.Set(KEComSpiTestFilePathAndName,NULL,NULL);
RResourceArchive resourceArchive;
resourceArchive.OpenL(TheFs, KEComSpiTestFilePathAndName);
CleanupClosePushL(resourceArchive);
// Checks SPI file type
TUid type = resourceArchive.Type();
test(type == KEcomSpiFileTypeUid);
// there is only 1 resource file
CPluginBase* entryBase=NULL;
CRegistryData::CDllData* dllData=NULL;
CRegistryData::CDriveData* driveData = NULL;
TDriveUnit driveUnit(spiPath.Drive());
TInt error=iRegistryData->FindDriveL(driveUnit,driveData);
test(error!=KErrNotFound);
while(!resourceArchive.End())
{
entryBase=CSpiPlugin::NewL(resourceArchive);
CleanupStack::PushL(entryBase);
dllData=CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);
TRAPD(err,iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
CleanupStack::Pop(dllData);
CleanupStack::PopAndDestroy(entryBase);
entryBase=NULL;
}
CleanupStack::PopAndDestroy(&resourceArchive);
// Currently only one interface definition in the resource file
const TInt ifCount = dllData->iIfList->Count();
test(ifCount == 1);
// Currently only one implemention for the above interface in the resource file
CRegistryData::CInterfaceData* ifData = (*(dllData->iIfList))[0];
const TInt impCount = ifData->iImplementations->Count();
test(impCount == 1);
// Interface UID verification
test(ifData->iInterfaceUid == iInterfaceUid);
delete dllData;
}
/**
@SYMTestCaseID SYSLIB-ECOM-UT-3566
@SYMTestCaseDesc Check that the ParseL for spi data with IIC Type 3 entry works correctly.
@SYMTestPriority High
@SYMTestActions Ensure ecomtesttype3.spi can be parsed successfully
and no leave occurs.
@SYMTestExpectedResults CRegistrar::ParseL() function parses SPI file without error.
Data is interpreted correctly.
@SYMEC EC43
*/
void CRegistrarTest::ParseSpiType3TestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3566 "));
TEntry spiEntry;
TParse spiPath;
//"Z:\\Test\\Data\\ecomtesttype3.spi" is used for testing. The only resource file included
//in the spi file is EComExample12.RSC
if (TheFs.Entry(KEComSpiTestFileType3PathAndName, spiEntry) != KErrNone)
return;
spiPath.Set(KEComSpiTestFileType3PathAndName,NULL,NULL);
RResourceArchive resourceArchive;
resourceArchive.OpenL(TheFs, KEComSpiTestFileType3PathAndName);
CleanupClosePushL(resourceArchive);
// Checks SPI file type
TUid type = resourceArchive.Type();
test(type == KEcomSpiFileTypeUid);
CRegistryData::CDriveData* driveData = NULL;
TDriveUnit driveUnit(spiPath.Drive());
TInt error=iRegistryData->FindDriveL(driveUnit,driveData);
test(error!=KErrNotFound);
// there is only 1 resource file in the spi file
while(!resourceArchive.End())
{
CPluginBase* entryBase = NULL;
entryBase=CSpiPlugin::NewL(resourceArchive);
CleanupStack::PushL(entryBase);
CRegistryData::CDllData* dllData = NULL;
dllData = CRegistryData::CDllData::NewLC(*(entryBase->iDllName),entryBase->iDllModifiedTime,entryBase->iDllSecondUid,entryBase->iDllThirdUid,driveData);
TRAPD(err,iStateAccessor->ParseL(*iRegistrar,entryBase,*dllData));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
// Currently only one interface definition in the resource file
// Checks the content of the DllData
test(dllData->iIfList->Count() == 1);
CRegistryData::CInterfaceData* ifData = NULL;
ifData = (*(dllData->iIfList))[0];
//There are 3 implementations for the above interface in the spi file.
//Since ecomtesttype3.spi is under Z: drive which is ROM based,
//the implementation (UID=0x10009E3D) will be created during Parsing.
//So, the total implementations is 3.
test(ifData->iImplementations->Count() == 3);
// Interface UID verification
test(ifData->iInterfaceUid == interfaceUidExample12);
// Fetches the list of extended interfaces for the second implementation
//Currently we have no extended Interface for the second implementation
CRegistryData::CImplementationData* implData = NULL;
implData = (*(ifData->iImplementations))[1];
CImplementationInformation* implInfo = NULL;
implInfo = implData->iImplInfo;
RArray<TUid>* extendedInterfaceList = implInfo->GetExtendedInterfaceList();
test(extendedInterfaceList->Count() == 0);
CleanupStack::PopAndDestroy(dllData);
CleanupStack::PopAndDestroy(entryBase);
}
CleanupStack::PopAndDestroy(&resourceArchive);
}
/**
The test executes by registering the Interface implementaion information
for an plugin entry.
@SYMTestCaseID SYSLIB-ECOM-CT-0732
@SYMTestCaseDesc Tests for CRegistrar::ParseRegistrationDataL() function
@SYMTestPriority High
@SYMTestActions Checks for directory entry for an Interface Implementation
Collection entry requires registration.Parses the associated resource file information where necessary
Checks for OOM or parsing error.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ0000
*/
void CRegistrarTest::ParseRegistrationDataTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0732 "));
TInt error=KErrNone;
TTime modified(0); //Dummy parameter...
TBool update = EFalse; //Dummy parameter...
TInt driveIndex = KErrNotFound;
CRegistryData::CImplementationData *implementationData = NULL;
CPluginBase* entryBase=NULL;
TUid implementationUid;
CRegistryData::CDriveData* driveData = NULL;
// Calling RegistryData->IsRegisteredWithDate to get the drive index,
// that will be used in the ParseRegistrationDataL call
// The drive should have been installed before registering any plugin
TRAP(error, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));
::LeaveIfErrNoMemory(error);
test(driveIndex != KErrNotFound);
TRAP(error, iRegistryData->IsRegisteredWithDate(
NewDllUid,
modified,
update,
driveData));
::LeaveIfErrNoMemory(error);
test(error == KErrNone);
//Creating the entry
TEntry rscBasedEntry;
rscBasedEntry.iName=KNewResourceFileNameOnly;
error = TheFs.Modified(KNewResourceFileNameC, rscBasedEntry.iModified);
test(error==KErrNone);
TParse rscPath;
rscPath.Set(KNewResourceFileNameC,NULL,NULL);
entryBase=CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), EFalse);
CleanupStack::PushL(entryBase);
//Trying to parse the registration data
update=ETrue;
TRAP(error,iStateAccessor->ParseRegistrationDataL(*iRegistrar,entryBase,iDriveUnit,update,driveIndex, driveData));
::LeaveIfErrNoMemory(error);
test(error == KErrNone);
CleanupStack::PopAndDestroy(entryBase);
// Calling DiscoveriesComplete for building the registry indexes
// as registration of new plugin has happened.
iStateAccessor->DiscoveriesComplete(*iRegistrar, EFalse);
//Now checking whether the implementation is already registered in the CRegistryData
//The only implementation Uid in EComExample5. see 101F847B.RSS
implementationUid=TUid::Uid(0x101F847C);
TUid dummyUid;
dummyUid.iUid = 0;
error = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, implementationUid, dummyUid, implementationData);
test(error == KErrNone);
test(implementationData != NULL);
}
/**
The test executes by registering the Interface implementation information
for an plugin with type 3 entry.
@SYMTestCaseID SYSLIB-ECOM-UT-3567
@SYMTestCaseDesc Tests for CRegistrar::ParseRegistrationDataL() function
@SYMTestPriority High
@SYMTestActions Checks for directory entry for an Interface Implementation
Collection with Type 3 entry requires registration.Parses the associated resource file information where necessary
@SYMTestExpectedResults CRegistrar::ParseRegistrationDataL() function parses resource file and registers
implementations correctly.
@SYMEC EC43
*/
void CRegistrarTest::ParseRegistrationDataType3TestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3567 "));
TInt error=KErrNone;
TTime modified(0); //Dummy parameter...
TBool update = EFalse; //Dummy parameter...
TInt driveIndex = KErrNotFound;
CRegistryData::CImplementationData *implementationData = NULL;
CPluginBase* entryBase = NULL;
TUid implementationUid;
CRegistryData::CDriveData* driveData = NULL;
// Calls iRegistryData->FindDriveL to get the drive index,
// that will be used in the ParseRegistrationDataL call.
// The drive should have been installed before registering any plugin
TRAP(error, driveIndex = iRegistryData->FindDriveL(iDriveUnit, driveData));
::LeaveIfErrNoMemory(error);
test(driveIndex != KErrNotFound);
// Calls iRegistryData->IsRegisteredWithDate to determine if the entry in the registry needs an update.
iRegistryData->IsRegisteredWithDate(Type3DllUid, modified, update, driveData);
//Creates the entry
TEntry rscBasedEntry;
rscBasedEntry.iName = KType3ResourceFileNameOnly;
error = TheFs.Modified(KType3ResourceFileNameC, rscBasedEntry.iModified);
test(error == KErrNone);
TParse rscPath;
rscPath.Set(KType3ResourceFileNameC,NULL,NULL);
entryBase = CSecurePlugin::NewL(TheFs,rscBasedEntry,rscPath.Drive(), EFalse);
CleanupStack::PushL(entryBase);
//Try to parse the registration data
TRAP(error,iStateAccessor->ParseRegistrationDataL(*iRegistrar,entryBase,iDriveUnit,update,driveIndex, driveData));
::LeaveIfErrNoMemory(error);
test(error == KErrNone);
CleanupStack::PopAndDestroy(entryBase);
// Calls DiscoveriesComplete for building the registry indexes
// as registration of new plugin has happened.
iStateAccessor->DiscoveriesComplete(*iRegistrar, EFalse);
// Checks whether the implementations are already registered in the CRegistryData
//The implementation Uids in EComExample12 are 0x10009E39, 0x10009E3C and 0x10009E3D
// Checks implementation 0x10009E39
implementationUid = TUid::Uid(0x10009E39);
TUid dummyUid;
dummyUid.iUid = 0;
error = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, implementationUid, dummyUid, implementationData);
test(error == KErrNone);
test(implementationData != NULL);
// Checks implementation 0x10009E3C
implementationUid = TUid::Uid(0x10009E3C);
dummyUid.iUid = 0;
error = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, implementationUid, dummyUid, implementationData);
test(error == KErrNone);
test(implementationData != NULL);
// Checks implementation 0x10009E3D
// This implementation is said it's ROM-only but is actually in RAM.
// So, this implementation will not be created.
implementationUid = TUid::Uid(0x10009E3D);
dummyUid.iUid = 0;
error = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, implementationUid, dummyUid, implementationData);
test(error == KErrNotFound);
test(implementationData == NULL);
}
/**
@SYMTestCaseID SYSLIB-ECOM-CT-0090
@SYMTestCaseDesc Check that the ParseL for spi data works correctly.
@SYMTestPriority High
@SYMTestActions Ensure ecomtest.spi can be parsed successfully
and no leave occurred.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ3655
*/
void CRegistrarTest::ParseSpiRegistrationDataTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0090 "));
TDriveUnit driveUnit(EDriveZ);
TEntry spiEntry;
test(TheFs.Entry(KEComSpiTestFilePathAndName, spiEntry) == KErrNone);
TParse spiPath;
spiPath.Set(KEComSpiTestFilePathAndName, NULL, NULL);
RResourceArchive resourceArchive;
resourceArchive.OpenL(TheFs, KEComSpiTestFilePathAndName);
CleanupClosePushL(resourceArchive);
// Checks SPI file type
TUid type = resourceArchive.Type();
test(type == KEcomSpiFileTypeUid);
CPluginBase* entryBase=NULL;
// there is only 1 resource file
while(!resourceArchive.End())
{
const TTime modified(0); //Dummy parameter...
TBool update = EFalse; //Dummy parameter...
TInt driveIndex = KErrNotFound;
CRegistryData::CDriveData* driveData = NULL;
// Calls RegistryData->IsRegisteredWithDate to get the drive index,
// that will be used in the ParseRegistrationDataL call
// The drive should have been installed before registering any plugin
TRAPD(error, driveIndex = iRegistryData->FindDriveL(driveUnit, driveData));
::LeaveIfErrNoMemory(error);
test(driveIndex != KErrNotFound);
TRAPD(err, (void)iRegistryData->IsRegisteredWithDate(
iDllUid,
modified,
update,
driveData));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
entryBase=CSpiPlugin::NewL(resourceArchive);
CleanupStack::PushL(entryBase);
TRAP(err, iStateAccessor->ParseRegistrationDataL(*iRegistrar,
entryBase,
driveUnit,
update,
driveIndex,
driveData));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
CleanupStack::PopAndDestroy(entryBase);
entryBase = NULL;
}
CleanupStack::PopAndDestroy(&resourceArchive);
// Calls DiscoveriesComplete for building the registry indexes
// as registration of new plugin has happened.
iStateAccessor->DiscoveriesComplete(*iRegistrar, EFalse);
CRegistryData::CImplementationData *implementationData = NULL;
TUid dummyUid;
dummyUid.iUid = 0;
TInt err = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, iImplementationUid, dummyUid, implementationData);
test(err == KErrNone);
test(implementationData != NULL);
}
/**
@SYMTestCaseID SYSLIB-ECOM-UT-3568
@SYMTestCaseDesc Check that the ParseL for spi data works correctly.
@SYMTestPriority High
@SYMTestActions Ensure ecomtesttype3.spi can be parsed successfully
and no leave occurs.
@SYMTestExpectedResults CRegistrar::ParseRegistrationDataL() function parses SPI file and registers
implementations correctly.
@SYMEC EC43
*/
void CRegistrarTest::ParseSpiRegistrationDataType3TestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-UT-3568 "));
TDriveUnit driveUnit(EDriveZ);
TEntry spiEntry;
//"Z:\\Test\\Data\\ecomtesttype3.spi" is used for testing. The only resource file included
//in the spi file is EComExample12.RSC
test(TheFs.Entry(KEComSpiTestFileType3PathAndName, spiEntry) == KErrNone);
TParse spiPath;
spiPath.Set(KEComSpiTestFileType3PathAndName, NULL, NULL);
RResourceArchive resourceArchive;
resourceArchive.OpenL(TheFs, KEComSpiTestFileType3PathAndName);
CleanupClosePushL(resourceArchive);
// Checks SPI file type
TUid type = resourceArchive.Type();
test(type == KEcomSpiFileTypeUid);
CPluginBase* entryBase = NULL;
// there is only 1 resource file in the spi file
while(!resourceArchive.End())
{
const TTime modified(0); //Dummy parameter...
TBool update = EFalse; //Dummy parameter...
TInt driveIndex = KErrNotFound;
CRegistryData::CDriveData* driveData = NULL;
// Calls RegistryData->FindDriveL to get the drive index,
// that will be used in the ParseRegistrationDataL call.
// The drive should have been installed before registering any plugin
TRAPD(error, driveIndex = iRegistryData->FindDriveL(driveUnit, driveData));
::LeaveIfErrNoMemory(error);
test(driveIndex != KErrNotFound);
iRegistryData->IsRegisteredWithDate(Type3DllUid,modified,update,driveData);
entryBase=CSpiPlugin::NewL(resourceArchive);
CleanupStack::PushL(entryBase);
TRAPD(err, iStateAccessor->ParseRegistrationDataL(*iRegistrar,
entryBase,
driveUnit,
update,
driveIndex,
driveData));
::LeaveIfErrNoMemory(err);
test(err == KErrNone);
CleanupStack::PopAndDestroy(entryBase);
entryBase = NULL;
}
CleanupStack::PopAndDestroy(&resourceArchive);
// Calls DiscoveriesComplete for building the registry indexes
// as registration of new plugin has happened.
iStateAccessor->DiscoveriesComplete(*iRegistrar, EFalse);
CRegistryData::CImplementationData *implementationData=NULL;
// Checks whether the implementations are already registered in the CRegistryData
// The implementation Uids in EComExample12 are 0x10009E39, 0x10009E3C and 0x10009E3D
// Checks implementation 0x10009E39
TUid implementationUid = TUid::Uid(0x10009E39);
TUid dummyUid;
dummyUid.iUid = 0;
TInt error = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, implementationUid, dummyUid, implementationData);
test(error == KErrNone);
test(implementationData != NULL);
// Checks implementation 0x10009E3C
implementationUid = TUid::Uid(0x10009E3C);
dummyUid.iUid = 0;
error = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, implementationUid, dummyUid, implementationData);
test(error == KErrNone);
test(implementationData != NULL);
// Checks implementation 0x10009E3D
// Since ecomtesttype3.spi is under Z: drive which is ROM based,
// the implementation (UID=0x10009E3D) will be created during Parsing.
implementationUid = TUid::Uid(0x10009E3D);
dummyUid.iUid = 0;
error = iRegistryDataStateAccessor->FindImplementation(*iRegistryData, implementationUid, dummyUid, implementationData);
test(error == KErrNone);
test(implementationData != NULL);
}
/**
@SYMTestCaseID SYSLIB-ECOM-CT-0184
@SYMTestCaseDesc Check that SSA related states transition as expected when registration is staged
@SYMTestPriority High
@SYMTestActions Use CRegistrar::ProcessSSAEventL to start registration in stages i.e. rom only
then non rom only. Check that the
CRegistrar state is transitioning correctly at every step.
@SYMTestExpectedResults The test must not fail.
@SYMPREQ PREQ967
*/
void CRegistrarTest::StateTransitionTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0184 "));
//After construction check that initial state is EReg_StartupInProgess
test(iStateAccessor->State(*iRegistrar) == CRegistrar::EReg_StartupInProgess);
//Call ProcessSSAEventL with EStartupStateUndefined. Check that state
// is not changed. i.e. still EReg_StartupInProgess
iRegistrar->ProcessSSAEventL(EStartupStateUndefined);
test(iStateAccessor->State(*iRegistrar) == CRegistrar::EReg_StartupInProgess);
//Call ProcessSSAEventL with EStartupStateCriticalStatic. Check that state
// is not changed. i.e. still EReg_StartupInProgess
iRegistrar->ProcessSSAEventL(EStartupStateCriticalStatic);
test(iStateAccessor->State(*iRegistrar) == CRegistrar::EReg_StartupInProgess);
//Call ProcessSSAEventL with EStartupStateCriticalDynamic. Check that state
// is not changed. i.e. still EReg_StartupInProgess
iRegistrar->ProcessSSAEventL(EStartupStateCriticalDynamic);
test(iStateAccessor->State(*iRegistrar) == CRegistrar::EReg_StartupInProgess);
//Call ProcessSSAEventL with EStartupStateNonCritical. Check that state
//is changed to EReg_StartupComplete
iRegistrar->ProcessSSAEventL(EStartupStateNonCritical);
test(iStateAccessor->State(*iRegistrar) == CRegistrar::EReg_StartupComplete);
}
/**
@SYMTestCaseID SYSLIB-ECOM-CT-0733
@SYMTestCaseDesc Tests the creation and deletion of CRegistrar
@SYMTestPriority High
@SYMTestActions Create and delete CRegistrar object,checks for open handles
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ0000
*/
LOCAL_C void CreateDeleteTestL()
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0733 CreateDeleteTestL "));
// Set up for heap leak checking
__UHEAP_MARK;
//Check Thread handles leak
TInt startProcessHandleCount = 0;
TInt startThreadHandleCount = 0;
TInt endProcessHandleCount = 0;
TInt endThreadHandleCount = 0;
RThread rThread;
rThread.HandleCount(startProcessHandleCount, startThreadHandleCount);
//CREATE DELETE TEST START//
CRegistrarTest* registrarTest = CRegistrarTest::NewL(EFalse);
test(registrarTest != NULL);
delete registrarTest;
//CREATE DELETE TEST END//
// Check for open handles
rThread.HandleCount(endProcessHandleCount, endThreadHandleCount);
test(startThreadHandleCount == endThreadHandleCount);
//Test ends
__UHEAP_MARKEND;
}
/*
LOCAL_C void OOMCreateDeleteTest()
{
//
// Out of memory test
// ------------------------------------------------------------------
//
test.Next(_L("OOM CreateDeleteTest"));
TInt err;
TInt failAt = 0;
__UNUSED_VAR(failAt);
CRegistrarTest* registrarTest = NULL;
do
{
__UHEAP_MARK;
// find out the number of open handles
TInt startProcessHandleCount;
TInt startThreadHandleCount;
RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
// Setting Heap failure for OOM test
__UHEAP_SETFAIL(RHeap::EDeterministic, ++failAt);
TRAP(err, registrarTest = CRegistrarTest::NewL(EFalse));
__UHEAP_SETFAIL(RHeap::ENone, 0);
delete registrarTest;
registrarTest = NULL;
// check that no handles have leaked
TInt endProcessHandleCount;
TInt endThreadHandleCount;
RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
test(startProcessHandleCount == endProcessHandleCount);
test(startThreadHandleCount == endThreadHandleCount);
__UHEAP_MARKEND;
}
while (err == KErrNoMemory);
test.Printf(_L("- Succeeded at heap failure rate of %i\n"), failAt);
test(err == KErrNone);
}
*/
// Type definition for pointer to member function.
// Used in calling the CDiscovererTest member function for testing.
typedef void (CRegistrarTest::*ClassFuncPtrL) (void);
/**
@SYMTestCaseID SYSLIB-ECOM-CT-0735
@SYMTestCaseDesc Wrapper function to call all test functions
@SYMTestPriority High
@SYMTestActions Calls up test functions of CRegistrarTest.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ0000
*/
/**
Wrapper function to call all test functions
@param testFuncL pointer to test function
@param aTestDesc test function name
*/
LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc, TBool aIsFullDiscovery)
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0735 "));
test.Next(aTestDesc);
__UHEAP_MARK;
// find out the number of open handles
TInt startProcessHandleCount;
TInt startThreadHandleCount;
RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
CRegistrarTest* registrarTest = CRegistrarTest::NewL(aIsFullDiscovery);
CleanupStack::PushL(registrarTest);
(registrarTest->*testFuncL)();
CleanupStack::PopAndDestroy(registrarTest);
// check that no handles have leaked
TInt endProcessHandleCount;
TInt endThreadHandleCount;
RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
test(startProcessHandleCount == endProcessHandleCount);
test(startThreadHandleCount == endThreadHandleCount);
__UHEAP_MARKEND;
}
/**
@SYMTestCaseID SYSLIB-ECOM-CT-0736
@SYMTestCaseDesc Function to call all test functions
@SYMTestPriority High
@SYMTestActions Calls up all OOM test functions of CRegistrarTest.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ0000
*/
/**
Utility function to continually invoke a test function and cause memory allocation failures
@param testFuncL pointer to OOM test function
@param tryCount specifies what value to start memory allocation failures at
@param increment how much to increase the point at which memory allocation will fail on each test attempt
@param stopCount the value of memory allocation failure to stop testing at
*/
TInt RunTestUnderOOMCondition(ClassFuncPtrL testFuncL, TBool aIsFullDiscovery, TInt tryCount, TInt increment, TInt stopCount)
{
test.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0736 "));
TInt err = KErrNone;
do
{
__UHEAP_MARK;
// find out the number of open handles
TInt startProcessHandleCount;
TInt startThreadHandleCount;
RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);
// Need to create object here as ECom has embedded TRAPs
// that will fail the test if memory not available
CRegistrarTest* registrarTest = CRegistrarTest::NewL(aIsFullDiscovery);
CleanupStack::PushL(registrarTest);
// Setting Heap failure for OOM test
__UHEAP_SETFAIL(RHeap::EDeterministic, tryCount);
TRAP(err, (registrarTest->*testFuncL)());
__UHEAP_SETFAIL(RHeap::ENone, 0);
CleanupStack::PopAndDestroy(registrarTest);
registrarTest = NULL;
// check that no handles have leaked
TInt endProcessHandleCount;
TInt endThreadHandleCount;
RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
test(startProcessHandleCount == endProcessHandleCount);
test(startThreadHandleCount == endThreadHandleCount);
__UHEAP_MARKEND;
tryCount = tryCount + increment;
} while((err == KErrNoMemory) && (tryCount != stopCount));
tryCount = tryCount - increment;
if (err == KErrNoMemory)
{
// test has not yet been able to pass due to memory allocation failures.
return -1;
}
test(err == KErrNone);
// If enough memory has finally been allocated for the test to pass then return
// the memory allocation counter value.
test.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
return tryCount;
}
/**
Wrapper function to call all OOM test functions
@param testFuncL pointer to OOM test function
@param aTestDesc test function name
*/
LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc, TBool aIsFullDiscovery)
{
test.Next(aTestDesc);
TInt startCount = 1;
TInt increment = 1;
TInt successRate = -1;
TInt stopCount = 256;
successRate = RunTestUnderOOMCondition(testFuncL, aIsFullDiscovery, startCount, increment, stopCount);
// (INC115057)
// When method CDiscoverer::CDirScanner::DoScanDriveL is encountered in a test hundreds
// of plug-in files will be scanned. It takes in the order of 3-4000 memory allocation failure
// loops (in techview context) before the scan is finished and the test can complete successfully.
// This will take over an hour. Instead determine the approximate failure point by
// testing with large increments between failures. Once a failure rate interval is found test
// for OOM conditions running up to it.
// This in effect means that we are checking OOM at the start and end of tests but skipping
// the scanning of each and every plugin in the middle of the test.
// (Note that CDiscoverer::CDirScanner::DoScanDriveL may return without leaving when it
// can't allocate TFileName. In this case it seems to this function that the test is
// successful. Therefore even if the successRate above indicates a pass the test is still
// re-run below with larger memory allocation failure valued to make sure that the test does
// in fact run to completion.
startCount = 256;
increment = 256;
stopCount = -1;
successRate = RunTestUnderOOMCondition(testFuncL, aIsFullDiscovery, startCount, increment, stopCount);
test(successRate > 0);
if (successRate > 256)
{
startCount = successRate - 256;
increment = 1;
stopCount = -1;
successRate = RunTestUnderOOMCondition(testFuncL, aIsFullDiscovery, startCount, increment, stopCount);
}
test(successRate > 0);
}
LOCAL_C void DoTestsL()
{
__UHEAP_MARK;
// Basic tests
CreateDeleteTestL();
DoBasicTestL(&CRegistrarTest::EnableDisableTestL, _L("EnableDisableTestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ResumeSuspendTestL, _L("ResumeSuspendTestL"), ETrue);
DoBasicTestL(&CRegistrarTest::DriveRemovedReinstatedTestL, _L("DriveRemovedReinstatedTestL"), ETrue);
DoBasicTestL(&CRegistrarTest::DiscoveriesBegin_Register_CompleteTestL, _L("DiscoveriesBegin_Register_CompleteTestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseTestL, _L("ParseTestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseType2TestL, _L("ParseType2TestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseType3TestL, _L("ParseType3TestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseType3BadDataTestL, _L("ParseType3BadDataTestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseRegistrationDataTestL, _L("ParseRegistrationDataTestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseRegistrationDataType3TestL, _L("ParseRegistrationDataType3TestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseSpiTestL, _L("ParseSpiTestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseSpiType3TestL, _L("ParseSpiType3TestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseSpiRegistrationDataTestL, _L("ParseSpiRegistrationDataTestL"), ETrue);
DoBasicTestL(&CRegistrarTest::ParseSpiRegistrationDataType3TestL, _L("ParseSpiRegistrationDataType3TestL"), ETrue);
DoBasicTestL(&CRegistrarTest::StateTransitionTestL, _L("StateTransitionTestL"), EFalse);
// OOM tests
// The OOM test for CRegistrar takes nearly 1 hour on hardware as it is reading the entire ecom.spi file
// Since ECOMSERVERTEST OOM test covered the full CRegistar OOM part, we will not run this the following
// test as that means 2 hours for ecom tests.
//OOMCreateDeleteTest();
DoOOMTestL(&CRegistrarTest::EnableDisableTestL, _L("OOM EnableDisableTestL"), ETrue);
DoOOMTestL(&CRegistrarTest::ResumeSuspendTestL, _L("OOM ResumeSuspendTestL"), ETrue);
DoOOMTestL(&CRegistrarTest::DriveRemovedReinstatedTestL, _L("OOM DriveRemovedReinstatedTestL"), ETrue);
DoOOMTestL(&CRegistrarTest::DiscoveriesBegin_Register_CompleteTestL, _L("OOM DiscoveriesBegin_Register_CompleteTestL"), ETrue);
DoOOMTestL(&CRegistrarTest::ParseTestL, _L("OOM ParseTestL"), ETrue);
DoOOMTestL(&CRegistrarTest::ParseType2TestL, _L("OOM ParseType2TestL"), ETrue);
DoOOMTestL(&CRegistrarTest::ParseType3TestL, _L("OOM ParseType3TestL"), ETrue);
DoOOMTestL(&CRegistrarTest::ParseSpiTestL, _L("OOM ParseSpiTestL"), ETrue);
DoOOMTestL(&CRegistrarTest::ParseSpiType3TestL, _L("OOM ParseSpiType3TestL"), ETrue);
DoOOMTestL(&CRegistrarTest::StateTransitionTestL, _L("OOM StateTransitionTestL"), EFalse);
// Not performing the OOM on ParseRegistrationDataL because of TRAPs present inside this function.
// The OOM error is trapped inside during the creation of the DllData but this error is not propagated to
// the calling funtion. Hence does not give the right results. However the normal test is performed above.
//DoOOMTestL(&CRegistrarTest::ParseRegistrationDataTestL,_L("OOM ParseRegistrationDataTestL"));
__UHEAP_MARKEND;
}
// Copies the Plugins to specific folder for testing purpose
LOCAL_C void CopyPlugins()
{
TInt err=KErrNone;
TRAP(err, EComTestUtils::FileManCopyFileL(KNewResourceFileNameZ, KNewResourceFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KNewDllFileNameZ, KNewDllFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType3ResourceFileNameZ, KType3ResourceFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType3DllFileNameZ, KType3DllFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType3BadDataResourceFileNameZ, KType3BadDataResourceFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType3BadDataDllFileNameZ, KType3BadDataDllFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType3BadData1ResourceFileNameZ, KType3BadData1ResourceFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType3BadData1DllFileNameZ, KType3BadData1DllFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType3BadData2ResourceFileNameZ, KType3BadData2ResourceFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType3BadData2DllFileNameZ, KType3BadData2DllFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType2ResourceFileNameZ, KType2ResourceFileNameC));
test(err==KErrNone);
TRAP(err, EComTestUtils::FileManCopyFileL(KType2DllFileNameZ, KType2DllFileNameC));
test(err==KErrNone);
}
// Deleting plugin from the RAM for cleanup purpose
inline LOCAL_C void DeleteTestPlugin()
{
TInt err=KErrNone;
TRAP(err, EComTestUtils::FileManDeleteFileL(KNewResourceFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KNewDllFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType3ResourceFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType3DllFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType3BadDataResourceFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType3BadDataDllFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType3BadData1ResourceFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType3BadData1DllFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType3BadData2ResourceFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType3BadData2DllFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType2ResourceFileNameC));
TRAP(err, EComTestUtils::FileManDeleteFileL(KType2DllFileNameC));
}
//Initialise the Active Scheduler
LOCAL_C void SetupL()
{
// Construct and install the Active Scheduler. The Active Schedular is needed
// by components used by this test as they are ActiveObjects.
TheActiveScheduler = new(ELeave)CActiveScheduler;
CActiveScheduler::Install(TheActiveScheduler);
}
GLDEF_C TInt E32Main()
{
__UHEAP_MARK;
test.Printf(_L("\n"));
test.Title();
test.Start( _L("Registrar Tests.") );
TheTrapCleanup = CTrapCleanup::New();
// Connect the file server instance
User::LeaveIfError(TheFs.Connect());
TRAPD(err, SetupL());
test(err == KErrNone);
// We need to clean up the registry files to ensure a fresh discovery that
// has the effect of taking certain pathways within the code. This
// tests the memory cleanup
// Delete the prevous data files so we rediscover from scratch
TRAP(err, EComTestUtils::FileManDeleteFileL(KDataDir));
CopyPlugins();
// The reason for the folowing delay is:
// ECOM server could be already started. It means that when we copy some
// ECOM plugins from Z: to C: drive - ECOM server should look for and
// find the new ECOM plugins. The ECOM server uses for that an active object,
// which scans plugin directories. So the discovering service is asynchronous.
// We have to wait some time until it finishes.
// Otherwise ListImplementationsL could fail to find requested implementations.
User::After(KOneSecond * 3);
// Call the main tests
TRAP(err, DoTestsL());
test(err == KErrNone);
// Cleanup files. If the cleanup fails that is no problem,
// as any subsequent tests will replace them. The only downside
// would be the disk not being tidied
DeleteTestPlugin();
delete TheActiveScheduler;
delete TheTrapCleanup;
TheFs.Close();
test.End();
test.Close();
__UHEAP_MARKEND;
return (KErrNone);
}