/*

* 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: 

*

*/

#include "installloghistorysteps.h"

#include <scs/cleanuputils.h>

#include "tscrdefs.h"

#include <usif/scr/screntries.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "screntries_internal.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

using namespace Usif;

_LIT(KScrLogFile, "!:\\private\\10285bc0\\scr.log");

// -----------CScrGetLogEntriesStep-----------------

CScrGetLogEntriesStep::CScrGetLogEntriesStep(CScrTestServer& aParent)	: CScrTestStep(aParent)

	{

	}

void CScrGetLogEntriesStep::ImplTestStepPreambleL()

	{

	CScrTestStep::ImplTestStepPreambleL();

	}

void CScrGetLogEntriesStep::GetLogEntriesFromConfigL(RPointerArray<CScrLogEntry>& aLogEntries)

	{

	TInt logCount = 0;

	if (!GetIntFromConfig(ConfigSection(), KLogsCountParamName, logCount))

		PrintErrorL(_L("Logs count was not found!"), KErrNotFound);

	if (logCount < 0)

			PrintErrorL(_L("Logs count is negative!"), KErrNotFound);

	TBuf<MAX_SCR_PARAM_LENGTH> componentNameParam, swTypeNameParam, versionParam, operationTypeParam, globalIdParam;

	for(TInt index=0; index < logCount; ++index)	

		{

		componentNameParam = KComponentName;

		swTypeNameParam = KSoftwareTypeName;

		versionParam = KVersionName;

		operationTypeParam = KOperationType;

		globalIdParam = KGlobalIdName;

		GenerateIndexedAttributeNameL(componentNameParam, index);

		GenerateIndexedAttributeNameL(swTypeNameParam, index);

		GenerateIndexedAttributeNameL(versionParam, index);

		GenerateIndexedAttributeNameL(operationTypeParam, index);

		GenerateIndexedAttributeNameL(globalIdParam, index);

		TPtrC componentName;

		if (!GetStringFromConfig(ConfigSection(), componentNameParam, componentName))

			{

			ERR_PRINTF2(_L("The component name param %S could not be found in configuration."), &componentNameParam);

			User::Leave(KErrNotFound);

			}

		TPtrC swTypeName;

		if (!GetStringFromConfig(ConfigSection(), swTypeNameParam, swTypeName))

			{

			ERR_PRINTF2(_L("The software type name param %S could not be found in configuration."), &swTypeNameParam);

			User::Leave(KErrNotFound);

			}

		TPtrC version;

		if (!GetStringFromConfig(ConfigSection(), versionParam, version))

			{

			ERR_PRINTF2(_L("The version param %S could not be found in configuration."), &versionParam);

			User::Leave(KErrNotFound);

			}

		TInt operationType;

		if (!GetIntFromConfig(ConfigSection(), operationTypeParam, operationType))

			{

			ERR_PRINTF2(_L("The operation type param %S could not be found in configuration."), &operationTypeParam);

			User::Leave(KErrNotFound);

			}

		TPtrC globalId;

		if (!GetStringFromConfig(ConfigSection(), globalIdParam, globalId))

			{

			ERR_PRINTF2(_L("The global id param %S could not be found in configuration."), &globalIdParam);

			User::Leave(KErrNotFound);

			}

		CScrLogEntry *logEntry = CScrLogEntry::NewLC(componentName, swTypeName, globalId, version, static_cast<TScrComponentOperationType>(operationType));

		aLogEntries.AppendL(logEntry);

		CleanupStack::Pop(logEntry); // Ownership is transferred

		}

	}

TBool operator ==(CScrLogEntry& aLhsEntry, CScrLogEntry& aRhsEntry)

	{

	return (aLhsEntry.ComponentName() == aRhsEntry.ComponentName() && 

			aLhsEntry.SoftwareTypeName() == aRhsEntry.SoftwareTypeName()&& 

			aLhsEntry.ComponentVersion() == aRhsEntry.ComponentVersion()&&

			aLhsEntry.GlobalId() == aRhsEntry.GlobalId()&&

			aLhsEntry.OperationType() == aRhsEntry.OperationType());

	}

TBool operator !=(CScrLogEntry& aLhsEntry, CScrLogEntry& aRhsEntry)

	{

	return !(aLhsEntry == aRhsEntry);

	}

TBool CScrGetLogEntriesStep::CompareLogEntriesL(RPointerArray<CScrLogEntry>& aFoundLogEntries, RPointerArray<CScrLogEntry>& aExpectedLogEntries)

	{

	TInt foundEntriesCount = aFoundLogEntries.Count();

	TInt expectedEntriesCount = aExpectedLogEntries.Count();

	if (foundEntriesCount != expectedEntriesCount)

		{

		ERR_PRINTF3(_L("The number of expected log entries %d did not match the number of provided log entries %d."), expectedEntriesCount, foundEntriesCount);

		return EFalse; 

		}

	for (TInt i = 0; i < foundEntriesCount; ++i)

		{

		if (*aFoundLogEntries[i] != *aExpectedLogEntries[i])

			{

			ERR_PRINTF2(_L("Log entry %d did not match."), i);

			return EFalse;

			}

		}	

	return ETrue;

	}

void CScrGetLogEntriesStep::ImplTestStepL()

	{

	TBool isLogFileReadOnly = EFalse; 

	(void)GetBoolFromConfig(ConfigSection(), _L("LogFileReadOnly"), isLogFileReadOnly); // since this is an optional param, ignore the return code.

	if(isLogFileReadOnly)

		{

		RBuf fn;

		fn.CreateL(KMaxFileName);

		fn.CleanupClosePushL();

		fn.Copy(KScrLogFile);

		RFs fs;

		User::Leave(fs.Connect());

		CleanupClosePushL(fs);

		fn[0] = fs.GetSystemDriveChar();

		User::LeaveIfError(fs.SetAtt(fn, KEntryAttReadOnly, 0));

		CleanupStack::PopAndDestroy(2, &fn); // fn, fs

		}

	RPointerArray<CScrLogEntry> expectedLogEntries;

	CleanupResetAndDestroyPushL(expectedLogEntries);

	GetLogEntriesFromConfigL(expectedLogEntries);

	TPtrC *ptrSwTypeName = NULL;

	TPtrC swTypeName;

	if (GetStringFromConfig(ConfigSection(), KSoftwareTypeName, swTypeName))

		{

		ptrSwTypeName = &swTypeName; 

		}

	RPointerArray<CScrLogEntry> retrievedLogEntries;

	CleanupResetAndDestroyPushL(retrievedLogEntries);

	iScrSession.RetrieveLogEntriesL(retrievedLogEntries, ptrSwTypeName);

	if (!CompareLogEntriesL(retrievedLogEntries, expectedLogEntries))

		{

		ERR_PRINTF1(_L("The retrieved log entries are different from the expected ones."));

		SetTestStepResult(EFail);

		}

	CleanupStack::PopAndDestroy(2, &expectedLogEntries); // expectedLogEntries, retrievedLogEntries	

	}

void CScrGetLogEntriesStep::ImplTestStepPostambleL()

	{

	CScrTestStep::ImplTestStepPostambleL();

	}

// -----------CScrSetLogFileReadOnlyAttrStep-----------------

CScrSetLogFileReadOnlyAttrStep::CScrSetLogFileReadOnlyAttrStep(CScrTestServer& aParent)	: CScrTestStep(aParent)

	{

	}

void CScrSetLogFileReadOnlyAttrStep::ImplTestStepPreambleL()

	{

	CScrTestStep::ImplTestStepPreambleL();

	}

void CScrSetLogFileReadOnlyAttrStep::ImplTestStepL()

	{

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	RBuf fn;

	fn.CreateL(KMaxFileName);

	fn.CleanupClosePushL();

	fn.Copy(KScrLogFile);

	fn[0] = fs.GetSystemDriveChar();

	TBool isLogFileReadOnly = EFalse; 

	if(!GetBoolFromConfig(ConfigSection(), _L("LogFileReadOnly"), isLogFileReadOnly))

		PrintErrorL(_L("LogFileReadOnly flag was not found!"), KErrNotFound);

	if(isLogFileReadOnly)

		User::LeaveIfError(fs.SetAtt(fn, KEntryAttReadOnly, 0));

	else

		User::LeaveIfError(fs.SetAtt(fn, 0, KEntryAttReadOnly));

	CleanupStack::PopAndDestroy(2, &fs); // fs, fn

	}

void CScrSetLogFileReadOnlyAttrStep::ImplTestStepPostambleL()

	{

	CScrTestStep::ImplTestStepPostambleL();

	}

// -----------CScrCreateLogFileStep-----------------

CScrCreateLogFileStep::CScrCreateLogFileStep(CScrTestServer& aParent)	: CScrTestStep(aParent)

	{

	}

void CScrCreateLogFileStep::ImplTestStepPreambleL()

	{

	CScrTestStep::ImplTestStepPreambleL();

	}

void CScrCreateLogFileStep::ImplTestStepL()

	{

	TInt numOfRecords;

	if (!GetIntFromConfig(ConfigSection(), KLogsCountParamName, numOfRecords))

		PrintErrorL(_L("The logs count param could not be found in configuration!"), KErrNotFound);

	TComponentId compId (0);

	for(TInt i=0; i<numOfRecords; ++i)

		{

		compId = iScrSession.AddComponentL(_L("TestComponentName"), _L("TestComponentVendor"),_L("plain"));

		iScrSession.SetComponentVersionL(compId,_L("1.2.3"));

		}

	}

void CScrCreateLogFileStep::ImplTestStepPostambleL()

	{

	CScrTestStep::ImplTestStepPostambleL();

	}