/*

* Copyright (c) 2004-2010 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: 

* SWIS test step implementation

*

*/

/**

 @file

*/

#include <e32std.h>

#include "tswisstep.h"

#include "testutilclientswi.h"

#include <test/testexecutelog.h>

#include <swi/launcher.h>

#include "sisregistrywritableentry.h"

#include "swi/sisregistrysession.h"

#include "swi/sisrevocationentry.h"

#include "swi/sisregistryentry.h"

#include "sisregistrywritablesession.h"

#include "swi/sisregistrypackage.h"

#include "cleanuputils.h"

#include "dessisdataprovider.h"

#include "cafsisdataprovider.h"

#include "swispubsubdefs.h"

#include "pkgremover.h"

#include "pkgremovererrors.h"

#include "sisregistryaccess_client.h"

#include <swi/swiutils.h>

#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK

#include <usif/scr/scr.h>

#include "installclientserver.h"

#endif

using namespace Swi;

using namespace Swi::Test;

//

// CSwisTestStep

//

_LIT(KExpectedHash, "hash");

_LIT(KExpectedDisplayText, "displaytext");

_LIT(KExpectedResultKeyFormat, "expectedresult%d");

const TInt KResultKeyMaxLength = 16;

const TInt KResultKeyMaxNum = 99;

const TInt KSetBufSize=64;

_LIT(KExpectedDialog, "dialog");

_LIT(KErrCode, "errorcode");

void CSwisTestStep::GetFileNamesForCheck(RArray<TPtrC>& aFileNumExist,RArray<TPtrC>& aFileNumNonExist,TReadType aReadType)

	{

	_LIT(KNumExistCancel, "numexistcancel"); // this specifies how many files to check for

	_LIT(KExistBaseCancel, "existcancel"); // + number (0-based) = file to check for

	_LIT(KNumNonExistCancel, "numnonexistcancel"); // this specifies how many files to check for

	_LIT(KNonExistBaseCancel, "nonexistcancel"); // + number (0-based) = file to check for

	_LIT(KNumExist, "numexist"); // this specifies how many files to check for

	_LIT(KExistBase, "exist"); // + number (0-based) = file to check for

	_LIT(KNumNonExist, "numnonexist"); // this specifies how many files to check for

	_LIT(KNonExistBase, "nonexist"); // + number (0-based) = file to check for

	_LIT(KNumRegistered, "numregistered");

	_LIT(KRegisteredBase, "registered");

	TInt entriesNumExist=0;

	TInt entriesNumNonExist=0;

	switch(aReadType)

		{

		case ESimpleType:

			{

			GetIntFromConfig(ConfigSection(), KNumExist, entriesNumExist);

			GetIntFromConfig(ConfigSection(), KNumNonExist, entriesNumNonExist);

			ExtractFileName(entriesNumExist, KExistBase, aFileNumExist);

			ExtractFileName(entriesNumNonExist, KNonExistBase, aFileNumNonExist);

			break;

			}

		case ECancelType:

			{

			GetIntFromConfig(ConfigSection(), KNumExistCancel, entriesNumExist);

			GetIntFromConfig(ConfigSection(), KNumNonExistCancel, entriesNumNonExist);

			ExtractFileName(entriesNumExist, KExistBaseCancel, aFileNumExist);

			ExtractFileName(entriesNumNonExist, KNonExistBaseCancel, aFileNumNonExist);

			break;

			}

		case ERegisteredType:

			{

			GetIntFromConfig(ConfigSection(), KNumRegistered, entriesNumExist);

			ExtractFileName(entriesNumExist, KRegisteredBase, aFileNumExist);

			break;

			}

		}

	}

void CSwisTestStep::ExtractFileName(TInt aEntries, const TDesC& aEntryBase, RArray<TPtrC>& aFileArray)

	{

	TPtrC fname;

	const TInt KKeyBufSize =64;

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

		{

		//construct name of the key

		TBuf<KKeyBufSize> keyBuf(aEntryBase);

		keyBuf.AppendNum(i);

		if(GetStringFromConfig(ConfigSection(),keyBuf,fname))

			{

			aFileArray.Insert(fname, i);

			}

		else

			{

			ERR_PRINTF2(_L("Config - filename item missing: %S"), &keyBuf);

			}

		}

	}

void CSwisTestStep::CheckIfFilesExist(TBool aCheckExist, const RArray<TPtrC>& aFileArray, RTestUtilSessionSwi& aTestUtil, TInt aMsecTimeout)

	{

	TInt nErr =0;

	if(aCheckExist)

		{

		for(TInt i =0; i< aFileArray.Count(); i++)

			{

			if(!aTestUtil.FileExistsL(aFileArray[i], aMsecTimeout))

				{

				ERR_PRINTF2(_L("File missing: %S"), &aFileArray[i]);

				nErr++;

				}

			}

		}

	else

		{

		for(TInt i =0; i< aFileArray.Count(); i++)

			{

			if(aTestUtil.FileExistsL(aFileArray[i], aMsecTimeout))

				{

				ERR_PRINTF2(_L("File exists (but shouldn't): %S"), &aFileArray[i]);

				nErr++;

				}

			}

		}

	// DEF118994 - If any files are incorrect the test result should be failure.

	if(nErr)

		{

		SetTestStepResult(EFail);

		}

	}

void CSwisTestStep::CheckRegistryEntry(RArray<TPtrC>& aFileArray)

	{

	TInt nErr=0;

	RPointerArray<HBufC> regFiles;

	TInt uid;

	if (GetHexFromConfig(ConfigSection(), _L("uid"), uid))

		{

		// trap this whole section

		enum { EConnectStage=1, EOpenStage, EEntryStage } stage = EConnectStage;

		TRAPD(err,

			{ 

			TUid regUid = {uid};

			RSisRegistrySession session;

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

			CleanupClosePushL(session);

			stage = EOpenStage;

			RSisRegistryEntry entry;

			User::LeaveIfError(entry.Open(session, regUid));

			CleanupClosePushL(entry);

			stage = EEntryStage;

			entry.FilesL(regFiles);

			CleanupStack::PopAndDestroy(2, &session);

			});

		if (err != KErrNone)

			{

			ERR_PRINTF3(_L("Couldn't query the registry at stage %d failed with error %d"), stage, err);

			}

		}

	for(TInt i = 0; i< aFileArray.Count(); i++)

		{

		TBool found = EFalse;

		for(TInt j = 0; j < regFiles.Count(); j++)

			{

			// Find this file name in the reg

			if (regFiles[j]->CompareF(aFileArray[i]) == 0)

				{

				found = ETrue;

				break;

				}

			}

		if (!found)

			{

			ERR_PRINTF2(_L("File not registered: %S"), &aFileArray[i]);

			nErr++;

			}

		}

	regFiles.ResetAndDestroy();

	if (nErr && (TestStepResult() == EPass))

		{

		SetTestStepResult(EFail);			

		}	

	}

void CSwisTestStep::CompareFilesL()

	{

	_LIT(KCompareFileAFormat, "comparefilea%d");

	_LIT(KCompareFileBFormat, "comparefileb%d");

	const TInt KKeyMaxLength = 15;

	const TInt KCompareFileMaxNum = 99;

	const TInt KExpectedHashLength = 160;

	RTestUtilSessionSwi testutil;

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

	CleanupClosePushL(testutil);

	TBool failedComparison(EFalse);

	TPtrC fileNameA;

	TPtrC fileNameB;

	TBuf<KKeyMaxLength> CompareFileAKey;

	TBuf<KKeyMaxLength> CompareFileBKey;

	HBufC8* hashBufA = HBufC8::NewLC(KExpectedHashLength);

	TPtr8 hashBufAPtr = hashBufA->Des();

	HBufC8* hashBufB = HBufC8::NewLC(KExpectedHashLength);

	TPtr8 hashBufBPtr = hashBufB->Des();

	for (TInt i = 1; i <= KCompareFileMaxNum; i++)

		{

		CompareFileAKey.Format(KCompareFileAFormat, i);

		CompareFileBKey.Format(KCompareFileBFormat, i);

		if (GetStringFromConfig(ConfigSection(), CompareFileAKey, fileNameA) &&

				 GetStringFromConfig(ConfigSection(), CompareFileBKey, fileNameB))

			{

			TInt err = testutil.GetFileHash(fileNameA, hashBufAPtr);

			if (err == KErrNone)

				{

				err = testutil.GetFileHash(fileNameB, hashBufBPtr);

				if (err != KErrNone)

					{

					ERR_PRINTF3(_L("Attempt to get hash for file %S returned %d"), &fileNameB, err);

					failedComparison = ETrue;

					}

				}

			else 

				{

				ERR_PRINTF3(_L("Attempt to get hash for file %S returned %d"), &fileNameA, err);

				failedComparison = ETrue;

				}

			if (err == KErrNone)

				{

				if (hashBufAPtr == hashBufBPtr)

					{

					INFO_PRINTF3(_L("Hashes for %S and %S match"), &fileNameA, &fileNameB);

					}

				else

					{

					ERR_PRINTF3(_L("Hashes for %S and %S do not match"), &fileNameA, &fileNameB);

					failedComparison = ETrue;

					}

				}

			}

		else

			{

			break;	

			}

		}

	CleanupStack::PopAndDestroy(3, &testutil);

	if (failedComparison && (TestStepResult() == EPass))

		{

		SetTestStepResult(EFail);			

		}

	}

void CSwisTestStep::CompareFileWithBufferL(const Swi::Test::CUIScriptAdaptor& ui)

	{

	_LIT(KExpectedDisplayTextFile,"ExpectedDisplayTextFile");

	TBool failedComparison(EFalse);

	TPtrC compareFileName;

	if (GetStringFromConfig(ConfigSection(), KExpectedDisplayTextFile, compareFileName))

		{

		const TDesC& actualDisplayText = ui.DisplayedTextActual();

		// Convert buffer from 16 bit to 8 bit

		HBufC8 *bufferText8 = HBufC8::NewLC(actualDisplayText.Size());

		bufferText8->Des().Copy(reinterpret_cast<const TUint8 *>(actualDisplayText.Ptr()), actualDisplayText.Size());

		// Read file contents into a buffer

		RFs fs;

		RFile file;

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

		CleanupClosePushL(fs);

		User::LeaveIfError(file.Open(fs, compareFileName, EFileRead));

		CleanupClosePushL(file);

		TInt seekPos = 0;

		file.Seek(ESeekStart, seekPos);

		HBufC8* bufferFile8 = HBufC8::NewLC(bufferText8->Size() + 1);

		TPtr8 bufferFilePtr(bufferFile8->Des());

		User::LeaveIfError(file.Read(bufferFilePtr, bufferText8->Size() + 1));

		if ((bufferFile8->Size() != bufferText8->Size()) ||

			(*bufferFile8 != *bufferText8))

			{

			failedComparison = ETrue;

			}

		if (failedComparison == EFalse)

			{

			INFO_PRINTF1(_L("File compares correctly with expected display text"));

			}

			else

			{

			ERR_PRINTF1(_L("File does NOT compare correctly with expected display text"));

			}

		CleanupStack::PopAndDestroy(4, bufferText8);	// fs, file, bufferFile8

		}

	if ((TestStepResult() == EPass) && failedComparison)

		{

		SetTestStepResult(EFail);			

		}

	}

void CSwisTestStep::CopyFilesL(const TDesC& aNumEntries, const TDesC& aFrom, const TDesC& aTo)

	{

	RTestUtilSessionSwi testutil;

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

	CleanupClosePushL(testutil);

	TInt numEntries=0;

	if (GetIntFromConfig(ConfigSection(), aNumEntries, numEntries) && numEntries!=0)

		{

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

			{

			TPtrC ptr;

			// construct name of "from" key

			TBuf<64> fromBuf(aFrom);

			fromBuf.AppendNum(i);

			// Read "from" key

			User::LeaveIfError(GetStringFromConfig(ConfigSection(), fromBuf, ptr));

			TFileName fromFile = ptr;

			// construct name of "to" key

			TBuf<64> toBuf(aTo);

			toBuf.AppendNum(i);

			// Read "to" key

			User::LeaveIfError(GetStringFromConfig(ConfigSection(), toBuf, ptr));

			TFileName toFile = ptr;

			User::LeaveIfError(testutil.Copy(fromFile, toFile));

			}

		}

	CleanupStack::PopAndDestroy(&testutil);

	}

void CSwisTestStep::DeleteFilesL(const TDesC& aNumEntries,

 								const TDesC& aDeleteKeyBase)

 	{

 	TInt numEntries=0;

 	if (GetIntFromConfig(ConfigSection(), aNumEntries, numEntries) && numEntries!=0)

 		{

		TBool ignoreErrors = EFalse;

		GetBoolFromConfig(ConfigSection(), _L("deleteignoreerrors"), ignoreErrors);

 		RTestUtilSessionSwi testutil;

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

 		CleanupClosePushL(testutil);

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

 			{

 			TPtrC ptr;

 			// construct name of delete file key

 			TBuf<64> deleteKey(aDeleteKeyBase);

 			deleteKey.AppendNum(i);

 			// Read delete file name

 			User::LeaveIfError(GetStringFromConfig(ConfigSection(), deleteKey, ptr));

 			TFileName deleteFile = ptr;

			TInt err = testutil.Delete(deleteFile);

			if(ignoreErrors && (err < 0))

				{

				INFO_PRINTF2(_L("Ignoring delete error code %d\n"), err);

				}

			else

				{

				User::LeaveIfError(err);

				}

 			}

 		CleanupStack::PopAndDestroy(&testutil);

 		}

 	}

void CSwisTestStep::SetClearReadOnlyFilesL(const TDesC& aNumEntries,

										   const TDesC& aFileKeyBase,

										   const TDesC& aSetClearOpBase)

	{

	TInt numEntries=0;

	if (GetIntFromConfig(ConfigSection(), aNumEntries, numEntries) && numEntries!=0)

		{

		RTestUtilSessionSwi testutil;

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

		CleanupClosePushL(testutil);

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

			{

			TPtrC ptr;

			// construct name of file key

			TBuf<64> key(aFileKeyBase);

			key.AppendNum(i);

			// Read file name

			User::LeaveIfError(GetStringFromConfig(ConfigSection(), key, ptr));

			TFileName filename = ptr;

			// construct name of operation key

			key.Copy(aSetClearOpBase);

			key.AppendNum(i);

			// Read operation (zero means clear read only attribute, non-zero means set)

			TInt operation(1);

			GetIntFromConfig(ConfigSection(), key, operation);

			User::LeaveIfError(testutil.SetReadOnly(filename, operation));

			}

		CleanupStack::PopAndDestroy(&testutil);

		}

	}

void CSwisTestStep::CheckPubSubStatus(TDesC& aPubSubStatus)

	{

	if (aPubSubStatus.Length() > 0)

		{

		TInt property = 0;

 		if (RProperty::Get(KUidSystemCategory, KUidSoftwareInstallKey, property) == KErrNone)

			{

			TSwisOperationStatus pubsubValue = TSwisOperationStatus(property & KSwisOperationStatusMask);

			TFileName swisStatus;

			if (pubsubValue == ESwisStatusAborted)

				{

				swisStatus.Copy(_L("ESwisStatusAborted"));

				}

			else if (pubsubValue == ESwisStatusSuccess)

				{

				swisStatus.Copy(_L("ESwisStatusSuccess"));

				}

			else if (pubsubValue == ESwisStatusNone)

				{

				swisStatus.Copy(_L("ESwisStatusNone"));

				}

			else

				{

				ERR_PRINTF2(_L("Pub & Sub status %d is not supported!"), pubsubValue);

				SetTestStepResult(EFail);

				return;

				}

			if(aPubSubStatus.Compare(swisStatus) != KErrNone)

 				{

				TSwisOperation opValue = TSwisOperation(property & KSwisOperationMask);

 				if ((pubsubValue == ESwisStatusNone) && (opValue == ESwisNone))

 					{

 					// Occationally this is the case for Functional-DP, as it misses the small window of time

 					// before ~CInstallSession() reseting KUidSoftwareInstallKey

 					// PDEF104559: INFO_PRINTF2(_L("WARNING: Pub & Sub Status is [%S] which was not as expected"), &swisStatus);	

 					}

  				else

  					{

  					INFO_PRINTF2(_L("Pub & Sub Status is [%S] which was not as expected"), &swisStatus);

            		SetTestStepResult(EFail);

  					}

 				}

 			else

 				{

				INFO_PRINTF2(_L("Pub & Sub Status is [%S] which was as expected"), &swisStatus);

            	}	

 			}

		}

	}

void CSwisTestStep::CheckPubSubStatusIdle()

	{

	TInt property = 0;

	TInt err = RProperty::Get(KUidSystemCategory, KUidSoftwareInstallKey, property);

	if (err == KErrNone)

		{

		TInt pubsubValue = property & KSwisOperationStatusMask;

		// Always check that the status returns to ESwisStatusNone, waiting

		// up to 5 seconds.

		TInt delaytime = 5;

		while (delaytime-- && err == KErrNone && pubsubValue != ESwisStatusNone)

			{

			User::After(1000000); // wait a second until the next test

			err = RProperty::Get(KUidSystemCategory, KUidSoftwareInstallKey, property);

			if (err == KErrNone)