installationservices/swcomponentregistry/test/tscr/source/componentquerysteps.cpp
/*
* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
* Implements test steps for component query APIs in the SCR
*
*/
#include "componentquerysteps.h"
#include <scs/cleanuputils.h>
#include <usif/scr/screntries.h>
#include "tscrdefs.h"
using namespace Usif;
// -----------CScrGetComponentStep-----------------
CScrGetComponentStep::CScrGetComponentStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetComponentStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetComponentStep::ImplTestStepL()
{
CComponentEntry *componentExpected = GetComponentEntryFromConfigLC();
CComponentEntry *componentRetrieved = CComponentEntry::NewL();
CleanupStack::PushL(componentRetrieved);
TLanguage locale = KUnspecifiedLocale;
GetLocaleFromConfigL(KComponentLocaleName, locale);
// Start timer just before invocation of SCR API
StartTimer();
if(!iScrSession.GetComponentL(componentExpected->ComponentId(), *componentRetrieved, locale))
{
ERR_PRINTF2(_L("Component Id %d doesn't exist!."), componentExpected->ComponentId());
User::Leave(KErrNotFound);
}
TTime time = componentRetrieved->InstallTimeL(); // For the sake of coverage print install time
INFO_PRINTF2(_L("Component InstallTime is %ld."), componentRetrieved->InstallTimeL().Int64());
if(*componentExpected != *componentRetrieved)
{
ERR_PRINTF5(_L("Returned component entry values(%S,%S) don't match with the expected ones(%S,%S)."),&componentRetrieved->Name(),&componentRetrieved->Vendor(),&componentExpected->Name(),&componentExpected->Vendor());
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(2, componentExpected); // componentExpected, componentRetrieved
}
void CScrGetComponentStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetComponentLocalizedStep-----------------
CScrGetComponentLocalizedStep::CScrGetComponentLocalizedStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetComponentLocalizedStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetComponentLocalizedStep::ImplTestStepL()
{
TComponentId expectedComponentId = GetComponentIdL();
RPointerArray<Usif::CLocalizableComponentInfo> compLocalizedInfoArrayExpected;
CleanupResetAndDestroyPushL(compLocalizedInfoArrayExpected);
GetLocalisedComponentsFromConfigL(compLocalizedInfoArrayExpected);
RPointerArray<Usif::CLocalizableComponentInfo> compLocalizedInfoArrayRetrieved;
// Start timer just before invocation of SCR API
StartTimer();
CleanupResetAndDestroyPushL(compLocalizedInfoArrayRetrieved);
iScrSession.GetComponentLocalizedInfoL(expectedComponentId, compLocalizedInfoArrayRetrieved);
if(compLocalizedInfoArrayExpected.Count()!=compLocalizedInfoArrayRetrieved.Count())
{
ERR_PRINTF1(_L("Returned component entry count doesnt match the expected count"));
SetTestStepResult(EFail);
}
else
{
for(TInt i=0;i<compLocalizedInfoArrayExpected.Count();i++)
{
if((compLocalizedInfoArrayExpected[i]->NameL()!=compLocalizedInfoArrayExpected[i]->NameL())||(compLocalizedInfoArrayExpected[i]->VendorL()!=compLocalizedInfoArrayExpected[i]->VendorL())||(compLocalizedInfoArrayExpected[i]->Locale()!=compLocalizedInfoArrayExpected[i]->Locale()))
{
ERR_PRINTF7(_L("Returned component entry values(%S,%S,%d) don't match with the expected ones(%S,%S,%d)."),&(compLocalizedInfoArrayRetrieved[i]->NameL()),&(compLocalizedInfoArrayRetrieved[i]->VendorL()),compLocalizedInfoArrayRetrieved[i]->Locale(),&(compLocalizedInfoArrayExpected[i]->NameL()),&(compLocalizedInfoArrayExpected[i]->VendorL()),compLocalizedInfoArrayExpected[i]->Locale());
SetTestStepResult(EFail);
}
}
}
CleanupStack::Pop(2,&compLocalizedInfoArrayExpected); //compLocalizedInfoArrayExpected ,compLocalizedInfoArrayRetrieved
compLocalizedInfoArrayRetrieved.ResetAndDestroy();
compLocalizedInfoArrayExpected.ResetAndDestroy();
}
void CScrGetComponentLocalizedStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetFilePropertiesStep-----------------
CScrGetFilePropertiesStep::CScrGetFilePropertiesStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetFilePropertiesStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetFilePropertiesStep::ImplTestStepL()
{
TComponentId componentId = GetComponentIdL();
TPtrC fileName;
GetFileNameFromConfigL(fileName);
RPointerArray<CPropertyEntry> expectedFileProperties;
CleanupResetAndDestroyPushL(expectedFileProperties);
GetPropertiesFromConfigL(expectedFileProperties);
RPointerArray<CPropertyEntry> retrievedFileProperties;
CleanupResetAndDestroyPushL(retrievedFileProperties);
// Start timer just before invocation of SCR API
StartTimer();
iScrSession.GetFilePropertiesL(componentId, fileName, retrievedFileProperties);
if(!ComparePropertiesL(expectedFileProperties, retrievedFileProperties))
{
ERR_PRINTF1(_L("Retrieved file properties don't match with the expected ones."));
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(2, &expectedFileProperties); // expectedFileProperties, retrievedFileProperties
}
void CScrGetFilePropertiesStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetFilePropertyStep-----------------
CScrGetFilePropertyStep::CScrGetFilePropertyStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetFilePropertyStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetFilePropertyStep::ImplTestStepL()
{
TComponentId componentId = GetComponentIdL();
CPropertyEntry *expectedProperty = GetPropertyFromConfigLC(ETrue);
TPtrC fileName;
GetFileNameFromConfigL(fileName);
// Start timer just before invocation of SCR API
StartTimer();
CPropertyEntry *retrievedProperty = iScrSession.GetFilePropertyL(componentId, fileName, expectedProperty->PropertyName());
if(!retrievedProperty)
{
ERR_PRINTF1(_L("The requested file property couldn't be found!"));
User::Leave(KErrNotFound);
}
CleanupStack::PushL(retrievedProperty);
if(*retrievedProperty != *expectedProperty)
{
ERR_PRINTF3(_L("The retrieved property(%S) doesn't match with the expected one(%S)."), &retrievedProperty->PropertyName(), &expectedProperty->PropertyName());
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(2, expectedProperty); // expectedProperty, retrievedProperty
}
void CScrGetFilePropertyStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetFileComponentsStep-----------------
CScrGetFileComponentsStep::CScrGetFileComponentsStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetFileComponentsStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetFileComponentsStep::ImplTestStepL()
{
TPtrC fileName;
GetFileNameFromConfigL(fileName);
RArray<TComponentId> expectedComponents;
CleanupClosePushL(expectedComponents);
GetComponentIdsFromConfigL(expectedComponents);
RArray<TComponentId> foundComponents;
CleanupClosePushL(foundComponents);
// Start timer just before invocation of SCR API
StartTimer();
iScrSession.GetComponentsL(fileName, foundComponents);
CompareComponentIdsL(foundComponents, expectedComponents);
CleanupStack::PopAndDestroy(2, &expectedComponents); // expectedComponents, foundComponents
}
void CScrGetFileComponentsStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetComponentPropertyStep-----------------
CScrGetComponentPropertyStep::CScrGetComponentPropertyStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetComponentPropertyStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetComponentPropertyStep::ImplTestStepL()
{
TComponentId componentId = GetComponentIdL();
CPropertyEntry *expectedProperty = GetPropertyFromConfigLC(ETrue,0,ETrue);
CPropertyEntry *retrievedProperty(0);
// Start timer just before invocation of SCR API
StartTimer();
switch(expectedProperty->PropertyType())
{
case CPropertyEntry::EBinaryProperty:
case CPropertyEntry::EIntProperty:
{
retrievedProperty = iScrSession.GetComponentPropertyL(componentId, expectedProperty->PropertyName());
break;
}
case CPropertyEntry::ELocalizedProperty:
{
CLocalizablePropertyEntry *locProperty = static_cast<CLocalizablePropertyEntry*>(expectedProperty);
retrievedProperty = iScrSession.GetComponentPropertyL(componentId, locProperty->PropertyName(), locProperty->LocaleL());
break;
}
}// switch
if(!retrievedProperty)
{
ERR_PRINTF1(_L("The requested component property couldn't be found!"));
User::Leave(KErrNotFound);
}
CleanupStack::PushL(retrievedProperty);
if(*retrievedProperty != *expectedProperty)
{
ERR_PRINTF3(_L("The retrieved property(%S) doesn't match with the expected one(%S)."), &retrievedProperty->PropertyName(), &expectedProperty->PropertyName());
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(2, expectedProperty); // expectedProperty, retrievedProperty
}
void CScrGetComponentPropertyStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetComponentPropertiesStep-----------------
CScrGetComponentPropertiesStep::CScrGetComponentPropertiesStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetComponentPropertiesStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetComponentPropertiesStep::ImplTestStepL()
{
TComponentId componentId = GetComponentIdL();
RPointerArray<CPropertyEntry> expectedProperties;
CleanupResetAndDestroyPushL(expectedProperties);
GetPropertiesFromConfigL(expectedProperties, ETrue); // ETrue means that localizable properties are supported
RPointerArray<CPropertyEntry> foundProperties;
CleanupResetAndDestroyPushL(foundProperties);
TLanguage locale = static_cast<TLanguage>(0);
// Start timer just before invocation of SCR API
StartTimer();
if(GetLocaleFromConfigL(locale))
{
iScrSession.GetComponentPropertiesL(componentId, foundProperties, locale);
}
else
{
iScrSession.GetComponentPropertiesL(componentId, foundProperties);
}
if (!ComparePropertiesL(foundProperties, expectedProperties))
{
ERR_PRINTF1(_L("The retrieved properties are different from the expected ones."));
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(2, &expectedProperties); // expectedProperties, foundProperties
}
void CScrGetComponentPropertiesStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetComponentIdsStep-----------------
CScrGetComponentIdsStep::CScrGetComponentIdsStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetComponentIdsStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetComponentIdsStep::ImplTestStepL()
{
CComponentFilter *componentFilter = ReadComponentFilterFromConfigLC();
INFO_PRINTF1(_L("Read component filter from configuration"));
// Get expected list of component ids from config
RArray<TComponentId> expectedComponentIds;
CleanupClosePushL(expectedComponentIds);
GetComponentIdsFromConfigL(expectedComponentIds);
RArray<TComponentId> foundComponentIds;
CleanupClosePushL(foundComponentIds);
// Start timer just before invocation of SCR API
StartTimer();
iScrSession.GetComponentIdsL(foundComponentIds, componentFilter);
CompareComponentIdsL(foundComponentIds, expectedComponentIds);
CleanupStack::PopAndDestroy(3, componentFilter); // foundComponentIds, expectedComponentIds, componentFilter
}
void CScrGetComponentIdsStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetComponentFilesCountStep-----------------
CScrGetComponentFilesCountStep::CScrGetComponentFilesCountStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetComponentFilesCountStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetComponentFilesCountStep::ImplTestStepL()
{
TComponentId componentId = GetComponentIdL();
TInt expectedFilesCountTmp(0);
if (!GetIntFromConfig(ConfigSection(), _L("ExpectedFilesCount"), expectedFilesCountTmp))
{
PrintErrorL(_L("ExpectedFilesCount property was not found!"), KErrNotFound);
}
if (expectedFilesCountTmp < 0)
{
PrintErrorL(_L("ExpectedFilesCount is negative!"), KErrArgument);
}
TUint expectedFilesCount = static_cast<TUint>(expectedFilesCountTmp);
// Start timer just before invocation of SCR API
StartTimer();
TUint foundFilesCount = iScrSession.GetComponentFilesCountL(componentId);
if (foundFilesCount != expectedFilesCount)
{
ERR_PRINTF4(_L("The retrieved files count is different from the expected one for component %d. Expected %d, but found %d"),
componentId, foundFilesCount, expectedFilesCount);
SetTestStepResult(EFail);
}
}
void CScrGetComponentFilesCountStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetComponentWithGlobalIdStep-----------------
CScrGetComponentWithGlobalIdStep::CScrGetComponentWithGlobalIdStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetComponentWithGlobalIdStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetComponentWithGlobalIdStep::ImplTestStepL()
{
CComponentEntry *componentExpected = GetComponentEntryFromConfigLC();
TLanguage locale = KUnspecifiedLocale;
GetLocaleFromConfigL(KComponentLocaleName, locale);
// Start timer just before invocation of SCR API
StartTimer();
CComponentEntry *componentRetrieved = iScrSession.GetComponentL(componentExpected->GlobalId(), componentExpected->SoftwareType());
if(!componentRetrieved)
{
INFO_PRINTF3(_L("Global Id (%S,%S) doesn't exist!."), &componentExpected->GlobalId(), &componentExpected->SoftwareType());
User::Leave(KErrNotFound);
}
CleanupStack::PushL(componentRetrieved);
if(*componentExpected != *componentRetrieved)
{
ERR_PRINTF5(_L("Returned component entry values(%S,%S) don't match with the expected ones(%S,%S)."),&componentRetrieved->Name(),&componentRetrieved->Vendor(),&componentExpected->Name(),&componentExpected->Vendor());
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(2, componentExpected); // componentExpected, componentRetrieved
}
void CScrGetComponentWithGlobalIdStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetComponentIdStep-----------------
CScrGetComponentIdStep::CScrGetComponentIdStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetComponentIdStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetComponentIdStep::ImplTestStepL()
{
CGlobalComponentId *globalId = GetGlobalComponentIdLC();
TComponentId expectedCompId = GetComponentIdL();
// Start timer just before invocation of SCR API
StartTimer();
TComponentId retrievedCompId = iScrSession.GetComponentIdL(globalId->GlobalIdName(), globalId->SoftwareTypeName());
CleanupStack::PopAndDestroy(globalId);
if(expectedCompId != retrievedCompId)
{
ERR_PRINTF3(_L("Returned component id (%d) don't match with the expected one(%d)."), retrievedCompId, expectedCompId);
SetTestStepResult(EFail);
}
}
void CScrGetComponentIdStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrGetGlobalIdListStep-----------------
CScrGetGlobalIdListStep::CScrGetGlobalIdListStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrGetGlobalIdListStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrGetGlobalIdListStep::ImplTestStepL()
{
CGlobalComponentId *globalId = GetGlobalComponentIdLC();
TBool noVerification = EFalse;
GetBoolFromConfig(ConfigSection(), _L("NoVerification"), noVerification);
RPointerArray<CVersionedComponentId> expectedVerCompIdList;
CleanupResetAndDestroyPushL(expectedVerCompIdList);
if(!noVerification)
{
GetExpectedVersionedComponentIdListL(expectedVerCompIdList);
}
RPointerArray<CVersionedComponentId> retrievedVerCompIdList;
CleanupResetAndDestroyPushL(retrievedVerCompIdList);
TPtrC globalIdType;
if (!GetStringFromConfig(ConfigSection(), KGlobalIdType, globalIdType))
PrintErrorL(_L("Global Id Type was not found!"), KErrNotFound);
// Start timer just before invocation of SCR API
StartTimer();
if(!globalIdType.CompareF(_L("Dependant")))
iScrSession.GetSupplierComponentsL(*globalId, retrievedVerCompIdList);
else if (!globalIdType.CompareF(_L("Supplier")))
iScrSession.GetDependantComponentsL(*globalId, retrievedVerCompIdList);
else {
ERR_PRINTF1(_L("The global Id type couldn't be identified."));
SetTestStepResult(EFail);
}
if (!noVerification && !CompareVersionedComponentIdsL(retrievedVerCompIdList, expectedVerCompIdList))
{
ERR_PRINTF1(_L("The retrieved global Ids are different from the expected ones."));
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(3, globalId); // depGlobalId, expectedGlobalIdList, retrievedGlobalIdList
}
void CScrGetGlobalIdListStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrValuesNegativeStep-----------------
CScrValuesNegativeStep::CScrValuesNegativeStep(CScrTestServer& aParent) : CScrTestStep(aParent)
{
}
void CScrValuesNegativeStep::ImplTestStepPreambleL()
{
CScrTestStep::ImplTestStepPreambleL();
}
void CScrValuesNegativeStep::ImplTestStepL()
{
CComponentFilter* componentFilter = CComponentFilter::NewLC();
TDriveList driveList;
// Set an empty drive list
componentFilter->SetInstalledDrivesL(driveList);
RSoftwareComponentRegistryView subSession;
CleanupClosePushL(subSession);
// Start timer just before invocation of SCR API
StartTimer();
TRAPD(err, subSession.OpenViewL(iScrSession, componentFilter));
if (err != KErrArgument)
{
ERR_PRINTF2(_L("Received incorrect error %d on missing param in filter."), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(2, componentFilter); // subSession
}
void CScrValuesNegativeStep::ImplTestStepPostambleL()
{
CScrTestStep::ImplTestStepPostambleL();
}
// -----------CScrOom-----------------
SCROufOfMemory::SCROufOfMemory(CScrTestServer& aParent) : CScrTestStep(aParent)
{
iFailRate = 0;
}
void SCROufOfMemory::ImplTestStepPreambleL()
{
}
void SCROufOfMemory::ImplTestStepL()
{
TInt i = 5000;
while(i--)
{
TRAPD(err, ExecuteL());
if (err == KErrNone)
{
}
}
}
void SCROufOfMemory::ImplTestStepPostambleL()
{
}
void SCROufOfMemory::ExecuteL()
{
// Connect to the SCR server
RSoftwareComponentRegistry scr;
TInt err = scr.Connect();
if (err != KErrNone)
{
INFO_PRINTF1(_L("Failed to connect to the SCR server"));
User::Leave(err);
}
CleanupClosePushL(scr);
scr.SetServerHeapFail(++iFailRate);
INFO_PRINTF2(_L("HeapFail set for %d allocation"),iFailRate);
// Create an SCR view
RSoftwareComponentRegistryView scrView;
scrView.OpenViewL(scr);
CleanupClosePushL(scrView);
// Iterate over the matching components
CComponentEntry* entry = CComponentEntry::NewLC();
while (scrView.NextComponentL(*entry))
{
RPointerArray<Usif::CLocalizableComponentInfo> compLocalizedInfoArray;
CleanupResetAndDestroyPushL(compLocalizedInfoArray);
scr.GetComponentLocalizedInfoL(entry->ComponentId(), compLocalizedInfoArray);
CleanupStack::Pop(&compLocalizedInfoArray);
compLocalizedInfoArray.ResetAndDestroy();
}
scrView.Close();
// Disconnect from the SCR server and cleanup the entry
scr.ResetServerHeapFail();
CleanupStack::PopAndDestroy();
CleanupStack::Pop();
CleanupStack::PopAndDestroy();
}