/*
* 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();
	}