--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swi/test/tsisregistrytest_legacy/sessionstep.cpp Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,1887 @@
+/*
+* 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 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:
+*
+*/
+
+
+/**
+ @file
+ @test
+ @internalTechnology
+*/
+
+#include <test/testexecutelog.h>
+
+#include "sessionstep.h"
+#include "sisregistrysession.h"
+#include "sisregistryentry.h"
+#include "sisregistrypackage.h"
+#include "installtypes.h"
+#include "cleanuputils.h"
+#include "hashcontainer.h"
+#include "testutilclientswi.h"
+#include "arrayutils.h"
+#include "sisregistrytoken.h"
+#include "sisregistrylog.h"
+#include <s32file.h>
+
+
+/////////////////////////////////////////////////////////////////////
+// defs, Constants used by test steps
+/////////////////////////////////////////////////////////////////////
+
+_LIT(KNoUid, "nouid");
+_LIT(KUid, "uid");
+_LIT(KDrivebitmapcount, "drivebitmapcout");
+_LIT(KSid, "sid");
+_LIT(KPackage, "package");
+_LIT(KVendor, "vendor");
+_LIT(KController, "ctl");
+_LIT(KKeyFormat, "-%02d");
+_LIT(KSidFileNameSec, "file");
+_LIT(KModFileName, "file");
+_LIT(KModTag, "modtag");
+_LIT(KHashFileName, "file");
+_LIT(KHashFileValue, "hashvalue");
+_LIT(KRootCertTag, "rootcert");
+_LIT(KResultTag, "expectedresult");
+_LIT(KDateTime, "datetime"); //YYYYMMDD:HHMMSS.MMMMMM
+_LIT(KPkgCount, "embeddingpkgcount");
+_LIT(KLanguage, "language");
+
+_LIT(KSisRegistryPath, "\\sys\\install\\sisregistry\\");
+_LIT(KCacheBackupFile, "\\sys\\install\\sisregistry\\backup.lst");
+_LIT(KCorruptCacheBackupFile, "z:\\tswi\\tsisregistrytest\\data\\hashforlang_txt.dat");
+_LIT(KSysBackupFileBackup, "\\sys\\install\\sisregistry\\backup.bak");
+
+/////////////////////////////////////////////////////////////////////
+// Tags used by test steps
+/////////////////////////////////////////////////////////////////////
+using namespace Swi;
+
+/////////////////////////////////////////////////////////////////////
+// CSisRegistryStep
+/////////////////////////////////////////////////////////////////////
+TVerdict CSisRegistrySessionStep::doTestStepPreambleL()
+ {
+ __UHEAP_MARK;
+
+ // Install an active scheduler
+ CActiveScheduler* s = new (ELeave) CActiveScheduler;
+ s->Install(s);
+
+ INFO_PRINTF1(_L("Connecting to SisRegistry.."));
+ User::LeaveIfError(iSisRegistry.Connect());
+ INFO_PRINTF1(_L("Connected!"));
+
+ return TestStepResult();
+ }
+
+TVerdict CSisRegistrySessionStep::doTestStepPostambleL()
+ {
+ // Remove the installed active scheduler
+ CActiveScheduler* s = CActiveScheduler::Current();
+ s->Install(NULL);
+ delete s;
+
+ iSisRegistry.Close();
+
+ __UHEAP_MARKEND;
+
+ return TestStepResult();
+ }
+/////////////////////////////////////////////////////////////////////
+// CEmbeddingPackageStep - Checks the embedding packages for a given package
+/////////////////////////////////////////////////////////////////////
+CEmbeddingPackageStep::CEmbeddingPackageStep()
+ {
+ SetTestStepName(KEmbeddingPackageStep);
+ }
+
+TVerdict CEmbeddingPackageStep::doTestStepL()
+ {
+ RSisRegistryEntry entry;
+ RPointerArray<Swi::CSisRegistryPackage> packages;
+ SetTestStepResult(EPass);
+
+ TUid uidOpen;
+ TInt embeddingPkgCount;
+ if(!GetUidFromConfig(ConfigSection(), KUid, uidOpen) || !GetIntFromConfig(ConfigSection(), KPkgCount, embeddingPkgCount))
+ {
+ ERR_PRINTF1(_L("Missing package Uid or expected package count"));
+ SetTestStepResult(EFail);
+ return TestStepResult();
+ }
+
+ if (KErrNone != entry.Open(iSisRegistry, uidOpen))
+ {
+ SetTestStepResult(EFail);
+ return TestStepResult();
+ }
+ CleanupClosePushL(entry);
+
+ entry.EmbeddingPackagesL(packages);
+ CleanupResetAndDestroyPushL(packages);
+
+
+ if(packages.Count() != embeddingPkgCount)
+ {
+ ERR_PRINTF3(_L("The actual number of embedding packages does not meet expected. Expected: %d Actual: %d"), embeddingPkgCount, packages.Count());
+ SetTestStepResult(EFail);
+ }
+ CleanupStack::PopAndDestroy(2, &entry);
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CSidFileStep - Checks the filename to sid mapping
+/////////////////////////////////////////////////////////////////////
+CSidFileStep::CSidFileStep()
+ {
+ SetTestStepName(KSidFileName);
+ }
+
+TVerdict CSidFileStep::doTestStepL()
+ {
+ RArray<TUid> theSids;
+ CleanupClosePushL(theSids);
+ GetUidArrayFromConfigL(ConfigSection(), KSid, theSids);
+
+ //RArray<TUid> thePackageUids;
+ //CleanupClosePushL(thePackageUids);
+ //GetUidArrayFromConfigL(ConfigSection(), KUid, thePackageUids);
+
+ RArray<TPtrC> expectedSidNames;
+ CleanupClosePushL(expectedSidNames);
+ GetStringArrayFromConfigL(ConfigSection(), KSidFileNameSec, expectedSidNames);
+
+ SetTestStepResult(EPass);
+
+ if (theSids.Count() != expectedSidNames.Count())
+ {
+ User::LeaveIfError(KErrCorrupt);
+ }
+
+ TBuf<KMaxFileName> fileName;
+
+ for (TInt sidCount(0); sidCount<theSids.Count(); sidCount++)
+ {
+ iSisRegistry.SidToFileNameL(theSids[sidCount],fileName);
+ if (expectedSidNames[sidCount].Compare(fileName) != 0)
+ {
+ SetTestStepResult(EFail);
+ break;
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&expectedSidNames);
+ //CleanupStack::PopAndDestroy(&thePackageUids);
+ CleanupStack::PopAndDestroy(&theSids);
+ return TestStepResult();
+ }
+
+////////////////////////////////////////////////////////////////////////
+// CModifiableFileStep - Checks whether the file is tagged as modifiable
+////////////////////////////////////////////////////////////////////////
+CModifiableFileStep::CModifiableFileStep()
+ {
+ SetTestStepName(KModifiableFile);
+ }
+
+TVerdict CModifiableFileStep::doTestStepL()
+ {
+ RArray<TPtrC> theFileNames;
+ CleanupClosePushL(theFileNames);
+ GetStringArrayFromConfigL(ConfigSection(), KModFileName, theFileNames);
+
+ RArray<TInt> expectedModifiableTags;
+ CleanupClosePushL(expectedModifiableTags);
+ GetIntArrayFromConfigL(ConfigSection(), KModTag, expectedModifiableTags);
+
+ SetTestStepResult(EPass);
+
+ if (theFileNames.Count() != expectedModifiableTags.Count())
+ {
+ User::LeaveIfError(KErrCorrupt);
+ }
+
+ TInt numModFiles = theFileNames.Count();
+
+ for (TInt i=0; i<numModFiles; i++)
+ {
+ TBool isFileModifiable = iSisRegistry.ModifiableL(theFileNames[i]);
+
+ INFO_PRINTF2(_L("File '%d':"), i);
+ INFO_PRINTF2(_L(" expected modifiable tag = %d"), expectedModifiableTags[i]);
+ INFO_PRINTF2(_L(" calculated modifiable tag = %d"), isFileModifiable);
+
+ if (expectedModifiableTags[i] != isFileModifiable)
+ {
+ SetTestStepResult(EFail);
+ break;
+ }
+ }
+
+ // Items popped and cleaned up from the stack (in this order):
+ // &expectedModifiableTags and &theFileNames.
+ CleanupStack::PopAndDestroy(2, &theFileNames);
+
+ return TestStepResult();
+ }
+
+////////////////////////////////////////////////////////////////////////
+// CFileHashStep - Checks the hash of a file
+////////////////////////////////////////////////////////////////////////
+CFileHashStep::CFileHashStep()
+ {
+ SetTestStepName(KFileHash);
+ }
+
+TVerdict CFileHashStep::doTestStepL()
+ {
+ // Get the filenames (for which the hash will be calculated)
+ // from the test section.
+ RArray<TPtrC> theFileNames;
+ CleanupClosePushL(theFileNames);
+ GetStringArrayFromConfigL(ConfigSection(), KHashFileName, theFileNames);
+
+ // Get the filenames that contain the expected hash values,
+ // from the test section.
+ RArray<TPtrC> expectedHashFiles;
+ CleanupClosePushL(expectedHashFiles);
+ GetStringArrayFromConfigL(ConfigSection(), KHashFileValue, expectedHashFiles);
+
+ // Initialise the test step result to pass.
+ SetTestStepResult(EPass);
+
+ // Ensure that there are as many filenames whose hash will be calculated,
+ // as there are files with expected hash values.
+ TInt numModFiles = theFileNames.Count();
+ if (numModFiles != expectedHashFiles.Count())
+ {
+ User::LeaveIfError(KErrCorrupt);
+ }
+
+ // For each file in config section KHashFileName, calculate its hash
+ // value and compare it with the corresponding expected hash value.
+ // Fail the test case if they don't match.
+ for (TInt i=0; i<numModFiles; i++)
+ {
+ INFO_PRINTF2(_L("Using SisRegistry to calculate hash for: %S"), &theFileNames[i]);
+ // Use SisRegistry to calculate the hash value for this file.
+ CHashContainer* hashContainer = iSisRegistry.HashL(theFileNames[i]);
+ CleanupStack::PushL(hashContainer);
+
+ const TDesC8& calcHashValue = hashContainer->Data();
+
+ // NOTE: The following block of code is temporary,
+ // so we can get the hash values first.
+ // -----------------------------------------------
+ // Name the file that will contain the expected hash value;
+ // on the 2nd iteration, this would have to be substituted
+ // by "c:\\system\\data\\hashForLang_txt.dat".
+ //_LIT(KHashFile, "c:\\system\\data\\hashForTestsidcheck_A_exe.dat");
+
+ // Create and open the (binary) file for writing later.
+ //RFs fs_util;
+ //User::LeaveIfError(fs_util.Connect());
+ //CleanupClosePushL(fs_util);
+
+ //RFile fileToWrite;
+
+ //User::LeaveIfError(fileToWrite.Create(fs_util, KHashFile,
+ // EFileWrite | EFileStream));
+ //CleanupClosePushL(fileToWrite);
+
+ //User::LeaveIfError(fileToWrite.Write(calcHashValue));
+ //CleanupStack::PopAndDestroy(&fileToWrite);
+ //CleanupStack::PopAndDestroy(&fs_util);
+ // -----------------------------------------------
+
+ // Open for reading the file that has the expected hash value.
+ INFO_PRINTF2(_L("Reading Expected hash value from: %S"), &expectedHashFiles[i]);
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ RFile fileToRead;
+ User::LeaveIfError(fileToRead.Open(fs, expectedHashFiles[i],
+ EFileRead | EFileShareReadersOnly | EFileStream));
+ CleanupClosePushL(fileToRead);
+
+ // Create a block of memory to store the expected hash value.
+ TInt fileSize = 0;
+ User::LeaveIfError(fileToRead.Size(fileSize));
+ HBufC8* memForExpectedHashValue = HBufC8::NewLC(fileSize);
+
+ // Read the expected hash value into the previously created memory block.
+ TPtr8 expectedHashValue(memForExpectedHashValue->Des());
+ User::LeaveIfError(fileToRead.Read(0, expectedHashValue, fileSize));
+
+ INFO_PRINTF1(_L("Comparing hash values"));
+
+ // Compare the calculated has value against its expected value.
+ if (calcHashValue.Compare(expectedHashValue) != KErrNone)
+ {
+ SetTestStepResult(EFail);
+
+ // Items popped and cleaned up from the stack (in this order):
+ // memForExpectedHashValue, &fileToRead, &fs and hashContainer.
+ CleanupStack::PopAndDestroy(4, hashContainer);
+
+ break;
+ }
+
+ // Items popped and cleaned up from the stack (in this order):
+ // memForExpectedHashValue, &fileToRead, &fs and hashContainer.
+ CleanupStack::PopAndDestroy(4, hashContainer);
+ }
+
+ // Items popped and cleaned up from the stack (in this order):
+ // &expectedHashFiles and &theFileNames.
+ CleanupStack::PopAndDestroy(2, &theFileNames);
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CInstalledUidsStep - checks installed packages Uids list
+/////////////////////////////////////////////////////////////////////
+CInstalledUidsStep::CInstalledUidsStep()
+ {
+ SetTestStepName(KInstalledUids);
+ }
+
+TVerdict CInstalledUidsStep::doTestStepL()
+ {
+ RArray<TUid> expectedUids;
+ CleanupClosePushL(expectedUids);
+ GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+
+ RArray<TUid> actualUids;
+ CleanupClosePushL(actualUids);
+ iSisRegistry.InstalledUidsL(actualUids);
+
+ SetTestStepResult(EPass);
+
+ for (TInt index=0; index < expectedUids.Count(); index++)
+ {
+ if(actualUids.Find(expectedUids[index]) != KErrNotFound)
+ {
+ INFO_PRINTF2(_L("Uid: 0x%08x was found!"), expectedUids[index]);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF2(_L("Uid: 0x%08x not found!"), expectedUids[index]);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(2, &expectedUids); //actualUids
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CInstalledPackagesStep - checks installed packages names and vendor list
+/////////////////////////////////////////////////////////////////////
+CInstalledPackagesStep::CInstalledPackagesStep()
+ {
+ SetTestStepName(KInstalledPackages);
+ }
+
+TVerdict CInstalledPackagesStep::doTestStepL()
+ {
+ RArray<TUid> expectedUids;
+ CleanupClosePushL(expectedUids);
+ GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+
+ RArray<TPtrC> expectedPackageNames;
+ CleanupClosePushL(expectedPackageNames);
+ GetStringArrayFromConfigL(ConfigSection(), KPackage, expectedPackageNames);
+
+ RArray<TPtrC> expectedVendorNames;
+ CleanupClosePushL(expectedVendorNames);
+ GetStringArrayFromConfigL(ConfigSection(), KVendor, expectedVendorNames);
+
+ RPointerArray<CSisRegistryPackage> packages;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+
+ iSisRegistry.InstalledPackagesL(packages);
+
+ SetTestStepResult(EPass);
+
+ for (TInt expected = 0; expected < expectedPackageNames.Count(); expected++)
+ {
+ TBool result = EFalse;
+ for (TInt actual = 0; actual < packages.Count(); ++actual)
+ {
+ if (packages[actual]->Uid() == expectedUids[expected] &&
+ !packages[actual]->Name().CompareF(expectedPackageNames[expected]) &&
+ !packages[actual]->Vendor().CompareF(expectedVendorNames[expected]))
+ {
+ result = ETrue;
+ break;
+ }
+ }
+
+ if(result)
+ {
+ INFO_PRINTF3(_L("Package %S by Vendor %S was found!"), &expectedPackageNames[expected], &expectedVendorNames[expected]);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF3(_L("Package %S by Vendor %S was not found!"), &expectedPackageNames[expected], &expectedVendorNames[expected]);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(4, &expectedUids); //packages, expectedVendorNames, expectedPackageNames
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CRemovablePackagesStep - checks removable packages names and vendor list
+/////////////////////////////////////////////////////////////////////
+CRemovablePackagesStep::CRemovablePackagesStep()
+ {
+ SetTestStepName(KRemovablePackages);
+ }
+
+TVerdict CRemovablePackagesStep::doTestStepL()
+ {
+ RArray<TUid> expectedNoUids;
+ CleanupClosePushL(expectedNoUids);
+ GetUidArrayFromConfigL(ConfigSection(), KNoUid, expectedNoUids);
+
+ RArray<TUid> expectedUids;
+ CleanupClosePushL(expectedUids);
+ GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+
+ RArray<TPtrC> expectedPackageNames;
+ CleanupClosePushL(expectedPackageNames);
+ GetStringArrayFromConfigL(ConfigSection(), KPackage, expectedPackageNames);
+
+ RArray<TPtrC> expectedVendorNames;
+ CleanupClosePushL(expectedVendorNames);
+ GetStringArrayFromConfigL(ConfigSection(), KVendor, expectedVendorNames);
+
+ RPointerArray<CSisRegistryPackage> packages;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+
+ iSisRegistry.RemovablePackagesL(packages);
+
+ TInt expected = 0;
+ for (expected = 0; expected < expectedPackageNames.Count(); expected++)
+ {
+ TBool result = EFalse;
+ for (TInt actual = 0; actual < packages.Count(); ++actual)
+ {
+ if (packages[actual]->Uid() == expectedUids[expected] &&
+ !packages[actual]->Name().CompareF(expectedPackageNames[expected]) &&
+ !packages[actual]->Vendor().CompareF(expectedVendorNames[expected]))
+ {
+ result = ETrue;
+ break;
+ }
+ }
+
+ if(result)
+ {
+ INFO_PRINTF3(_L("Package %S by Vendor %S was found!"), &expectedPackageNames[expected], &expectedVendorNames[expected]);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF3(_L("Package %S by Vendor %S was not found!"), &expectedPackageNames[expected], &expectedVendorNames[expected]);
+ }
+ }
+
+ for (expected = 0; expected < expectedNoUids.Count(); expected++)
+ {
+ TBool result = ETrue;
+ for (TInt actual = 0; actual < packages.Count(); ++actual)
+ {
+ if (packages[actual]->Uid() == expectedNoUids[expected])
+ {
+ result = EFalse;
+ break;
+ }
+ }
+
+ if(result)
+ {
+ INFO_PRINTF2(_L("Non-Removable Package %d was not found!"), &expectedNoUids[expected]);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF2(_L("Non-Removable Package %d was found!"), &expectedNoUids[expected]);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(5, &expectedNoUids); //packages, expectedVendorNames, expectedPackageNames
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CNonRemovablePackagesStep - checks Non-removable packages in rom
+/////////////////////////////////////////////////////////////////////
+CInRomNonRemovablePackage::CInRomNonRemovablePackage()
+ {
+ SetTestStepName(KInRomNonRemovablePackages);
+ }
+
+TVerdict CInRomNonRemovablePackage::doTestStepL()
+ {
+ RPointerArray<CSisRegistryPackage> packages;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+
+ iSisRegistry.RemovablePackagesL(packages);
+
+ RSisRegistryEntry entry;
+ TBool inrom = EFalse;
+ for (TInt i = 0; i < packages.Count(); ++i)
+ {
+ User::LeaveIfError(entry.OpenL(iSisRegistry, *packages[i]));
+ inrom = entry.IsInRomL();
+
+ if(inrom)
+ {
+ SetTestStepResult(EFail);
+ }
+ }
+ INFO_PRINTF1(_L("Packages which are removable are not in ROM"));
+ CleanupStack::PopAndDestroy(&packages);
+
+ return TestStepResult();
+ }
+
+//////////////////////////////////////////////////////////////////////////////
+// CInstalledDrives - check all the drives where files are installed from SIS
+//////////////////////////////////////////////////////////////////////////////
+CInstalledDrives::CInstalledDrives()
+ {
+ SetTestStepName(KInstalledDrives);
+ }
+
+TVerdict CInstalledDrives::doTestStepL()
+ {
+ TInt drivebitmapcount=0;
+ TUid expectedUid;
+ GetUidFromConfig(ConfigSection(), KUid, expectedUid);
+ GetIntFromConfig(ConfigSection(), KDrivebitmapcount, drivebitmapcount);
+
+ RPointerArray<CSisRegistryPackage> packages;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+
+ iSisRegistry.RemovablePackagesL(packages);
+
+ RSisRegistryEntry entry;
+ CleanupClosePushL(entry);
+
+ for (TInt i=0; i<packages.Count(); i++)
+ {
+ if(expectedUid == packages[i]->Uid())
+ {
+ User::LeaveIfError(entry.OpenL(iSisRegistry, *packages[i]));
+ TUint drives = entry.InstalledDrivesL();
+ if(drives != drivebitmapcount)
+ {
+ SetTestStepResult(EFail);
+ INFO_PRINTF1(_L("Drive bitmask count is not Correct..."));
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Drive bitmask count is OK..."));
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(2,&packages); //entry
+
+ return TestStepResult();
+ }
+
+
+/////////////////////////////////////////////////////////////////////
+// CIsUidInstalledStep - checks whether an Uid is registered
+/////////////////////////////////////////////////////////////////////
+CIsUidInstalledStep::CIsUidInstalledStep()
+ {
+ SetTestStepName(KIsUidInstalled);
+ }
+
+TVerdict CIsUidInstalledStep::doTestStepL()
+ {
+ RArray<TUid> expectedUids;
+ CleanupClosePushL(expectedUids);
+ GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+
+ SetTestStepResult(EPass);
+ for (TInt index = 0; index < expectedUids.Count(); index++)
+ {
+ if(iSisRegistry.IsInstalledL(expectedUids[index]))
+ {
+ INFO_PRINTF2(_L("Uid: 0x%08x was found!"), expectedUids[index]);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF2(_L("Uid: 0x%08x not found!"), expectedUids[index]);
+ }
+ }
+ CleanupStack::PopAndDestroy(&expectedUids);
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CIsPackageInstalledStep - checks if packages are registered
+/////////////////////////////////////////////////////////////////////
+
+CIsPackageInstalledStep::CIsPackageInstalledStep()
+ {
+ SetTestStepName(KIsPackageInstalled);
+ }
+
+TVerdict CIsPackageInstalledStep::doTestStepL()
+ {
+ RArray<TUid> expectedUids;
+ CleanupClosePushL(expectedUids);
+ GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+
+ RArray<TPtrC> expectedPackageNames;
+ CleanupClosePushL(expectedPackageNames);
+ GetStringArrayFromConfigL(ConfigSection(), KPackage, expectedPackageNames);
+
+ RArray<TPtrC> expectedVendorNames;
+ CleanupClosePushL(expectedVendorNames);
+ GetStringArrayFromConfigL(ConfigSection(), KVendor, expectedVendorNames);
+
+ RPointerArray<CSisRegistryPackage> packages;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+
+ SetTestStepResult(EPass);
+ for (TInt i = 0; i < expectedUids.Count(); ++i)
+ {
+ CSisRegistryPackage* package = CSisRegistryPackage::NewLC(expectedUids[i],
+ expectedPackageNames[i], expectedVendorNames[i]);
+ package->SetIndex(0);
+
+ RSisRegistryEntry entry;
+ CleanupClosePushL(entry);
+
+ TInt err = entry.Open(iSisRegistry, package->Name(), package->Vendor());
+ if (err != KErrNone)
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF2(_L("Uid: 0x%08x not found!"), expectedUids[i]);
+ }
+
+ CleanupStack::PopAndDestroy(2, package); // entry
+ }
+
+ CleanupStack::PopAndDestroy(4, &expectedUids); // expectedVendorNames, expectedPackageNames
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CIsControllerInstalledStep - checks whether a Controller is present
+/////////////////////////////////////////////////////////////////////
+CIsControllerInstalledStep::CIsControllerInstalledStep()
+ {
+ SetTestStepName(KIsControllerInstalled);
+ }
+
+TVerdict CIsControllerInstalledStep::doTestStepL()
+ {
+ RArray<TPtrC> expectedControllers;
+ CleanupClosePushL(expectedControllers);
+ GetStringArrayFromConfigL(ConfigSection(), KController, expectedControllers);
+
+ SetTestStepResult(EPass);
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+ for (TInt index = 0; index < expectedControllers.Count(); index++)
+ {
+ RFile file;
+ CleanupClosePushL(file);
+ // open file and read the data
+ User::LeaveIfError(file.Open(fs, expectedControllers[index], EFileRead | EFileShareReadersOnly));
+ // read the data from the file
+ TInt fileSize;
+ file.Size(fileSize);
+ HBufC8* buffer = HBufC8::NewLC(fileSize);
+ TPtr8 ptr(buffer->Des());
+ file.Read(0, ptr, fileSize);
+
+ if(iSisRegistry.IsInstalledL(*buffer))
+ {
+ INFO_PRINTF2(_L("%S matching controller was found!"), &expectedControllers[index]);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ INFO_PRINTF2(_L("%S controller did not match expected!"), &expectedControllers[index]);
+ }
+ CleanupStack::PopAndDestroy(2, &file); //buffer
+ }
+ CleanupStack::PopAndDestroy(2, &expectedControllers); //fs
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CGetControllersStep - checks whether one can get the binary version
+// of entry controllers present
+/////////////////////////////////////////////////////////////////////
+CGetControllersStep::CGetControllersStep()
+ {
+ SetTestStepName(KGetControllers);
+ }
+
+TVerdict CGetControllersStep::doTestStepL()
+ {
+ SetTestStepResult(EPass);
+
+ RArray<TUid> expectedUids;
+ CleanupClosePushL(expectedUids);
+ GetUidArrayFromConfigL(ConfigSection(), KUid, expectedUids);
+
+ RFs fs;
+ CleanupClosePushL(fs);
+ User::LeaveIfError(fs.Connect());
+
+ for (TInt index = 0; index < expectedUids.Count(); index++)
+ {
+ TInt res;
+ RSisRegistryEntry entry;
+ CleanupClosePushL(entry);
+ INFO_PRINTF3(_L("Open: %08x %d entry!"), expectedUids[index],index);
+ res = entry.Open(iSisRegistry, expectedUids[index]);
+ if (res == KErrNone)
+ {
+ RPointerArray<HBufC8> actualControllers;
+ CleanupResetAndDestroy<RPointerArray<HBufC8> >::PushL(actualControllers);
+ TRAP(res, entry.ControllersL(actualControllers));
+ if (res != KErrNone)
+ {
+ INFO_PRINTF3(_L("Accessing controllers for uid: %08x left with %d!"), expectedUids[index], res);
+ SetTestStepResult(EFail);
+ User::Leave(res);
+ }
+
+ HBufC* keyName = HBufC::NewLC(KUid().Length() + KKeyFormat().Length()
+ + KController().Length() + KKeyFormat().Length());
+ TPtr ptr(keyName->Des());
+ ptr = KUid();
+ ptr.AppendFormat(KKeyFormat(), index + 1);
+ ptr.Append(KController);
+
+ RArray<TPtrC> controllerFilenames;
+ CleanupClosePushL(controllerFilenames);
+ GetStringArrayFromConfigL(ConfigSection(), ptr, controllerFilenames);
+
+ if (controllerFilenames.Count() != actualControllers.Count())
+ {
+ ERR_PRINTF3(_L("Actual Controllers = %d, Expected Controllers = %d"), actualControllers.Count(), controllerFilenames.Count());
+ SetTestStepResult(EFail);
+ }
+
+ for (TInt filename = 0; filename < controllerFilenames.Count(); filename++)
+ {
+ RFile file;
+ CleanupClosePushL(file);
+ // open file and read the data
+ User::LeaveIfError(file.Open(fs, controllerFilenames[filename], EFileRead | EFileShareReadersOnly));
+ // read the data from the file
+ TInt fileSize;
+ file.Size(fileSize);
+ // create a buffer according to file size and load it with data
+ HBufC8* buffer = HBufC8::NewLC(fileSize);
+ TPtr8 ptr(buffer->Des());
+ file.Read(0, ptr, fileSize);
+
+ TBool found = EFalse;
+ for (TInt controller = 0; controller < actualControllers.Count(); controller++)
+ {
+ if(*actualControllers[controller] == *buffer)
+ {
+ found = ETrue;
+ break;
+ }
+ }
+
+ if(found)
+ {
+ INFO_PRINTF3(_L("Matching controller #%d found for Uid: %08x!"), filename, expectedUids[index]);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF3(_L("Matching controller #%d not found for Uid: %08x!"), filename, expectedUids[index]);
+ }
+
+ // cleanup
+ CleanupStack::PopAndDestroy(2, &file); //buffer
+ }
+
+ CleanupStack::PopAndDestroy(3, &actualControllers); // controllerFilenames, keyNames
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ INFO_PRINTF2(_L("Failed Open Uid: %08x entry!"), expectedUids[index]);
+ }
+
+ CleanupStack::PopAndDestroy(&entry);
+ }
+
+ CleanupStack::PopAndDestroy(2, &expectedUids);
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CEntryUidOpenCloseStep
+/////////////////////////////////////////////////////////////////////
+CEntryUidOpenCloseStep::CEntryUidOpenCloseStep()
+ {
+ SetTestStepName(KEntryUidOpenClose);
+ }
+
+TVerdict CEntryUidOpenCloseStep::doTestStepL()
+ {
+ RArray<TUid> uids;
+ CleanupClosePushL(uids);
+ iSisRegistry.InstalledUidsL(uids);
+
+ SetTestStepResult(EPass);
+ for(TInt index = 0; index < uids.Count(); index++)
+ {
+ Swi::RSisRegistryEntry entry;
+ CleanupClosePushL(entry);
+ TInt result = entry.Open(iSisRegistry, uids[index]);
+ if (result == KErrNone)
+ {
+ INFO_PRINTF2(_L("Uid: 0x%08x was opened successfully!"), uids[index]);
+ entry.Close();
+ INFO_PRINTF2(_L("Uid: 0x%08x was closed successfully!"), uids[index]);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF3(_L("Uid: 0x%08x not opened, error %d!"), uids[index], result);
+ }
+ CleanupStack::PopAndDestroy(&entry);
+ }
+
+ CleanupStack::PopAndDestroy(&uids);
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CEntryPackageOpenCloseStep
+/////////////////////////////////////////////////////////////////////
+CEntryPackageOpenCloseStep::CEntryPackageOpenCloseStep()
+ {
+ SetTestStepName(KEntryPackageOpenClose);
+ }
+
+TVerdict CEntryPackageOpenCloseStep::doTestStepL()
+ {
+ RPointerArray<CSisRegistryPackage> packages;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+
+ iSisRegistry.InstalledPackagesL(packages);
+
+ SetTestStepResult(EPass);
+ for(TInt index = 0; index < packages.Count(); index++)
+ {
+ TPtrC package = packages[index]->Name();
+ TPtrC vendor = packages[index]->Vendor();
+
+ Swi::RSisRegistryEntry entry;
+
+ TInt result = entry.OpenL(iSisRegistry, *packages[index]);
+ if (result == KErrNone)
+ {
+ CleanupClosePushL(entry);
+ INFO_PRINTF3(_L("Package %S by Vendor %S was opened successfully!"), &package, &vendor);
+ CleanupStack::PopAndDestroy(&entry);
+ INFO_PRINTF3(_L("Package %S by Vendor %S was closed successfully!"), &package, &vendor);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF4(_L("Package %S by Vendor %S not opened, error %d!"), &package, &vendor, result);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&packages);
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CEntryNameOpenCloseStep
+/////////////////////////////////////////////////////////////////////
+CEntryNameOpenCloseStep::CEntryNameOpenCloseStep()
+ {
+ SetTestStepName(KEntryNameOpenClose);
+ }
+
+TVerdict CEntryNameOpenCloseStep::doTestStepL()
+ {
+ RPointerArray<CSisRegistryPackage> packages;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+
+ iSisRegistry.InstalledPackagesL(packages);
+
+ SetTestStepResult(EPass);
+ for(TInt index = 0; index < packages.Count(); index++)
+ {
+ TPtrC package = packages[index]->Name();
+ TPtrC vendor = packages[index]->Vendor();
+
+ Swi::RSisRegistryEntry entry;
+
+ TInt result = entry.Open(iSisRegistry, package, vendor);
+ if (result == KErrNone)
+ {
+ CleanupClosePushL(entry);
+ INFO_PRINTF3(_L("Package %S by Vendor %S was opened successfully!"), &package, &vendor);
+ CleanupStack::PopAndDestroy(&entry);
+ INFO_PRINTF3(_L("Package %S by Vendor %S was closed successfully!"), &package, &vendor);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF4(_L("Package %S by Vendor %S not opened, error %d!"), &package, &vendor, result);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&packages);
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CEntryMethodsTestStep - tests specific to entry methods
+/////////////////////////////////////////////////////////////////////
+CEntryMethodsStep::CEntryMethodsStep()
+ {
+ SetTestStepName(KEntryMethods);
+ }
+
+TVerdict CEntryMethodsStep::doTestStepL()
+ {
+ RPointerArray<CSisRegistryPackage> packages;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+
+ iSisRegistry.InstalledPackagesL(packages);
+
+ SetTestStepResult(EPass);
+ for(TInt index = 0; index < packages.Count(); index++)
+ {
+ TPtrC package = packages[index]->Name();
+ TPtrC vendor = packages[index]->Vendor();
+
+ Swi::RSisRegistryEntry entry;
+
+ INFO_PRINTF3(_L("Opening Package %S by Vendor %S..."), &package, &vendor);
+ User::LeaveIfError(entry.OpenL(iSisRegistry, *packages[index]));
+ CleanupClosePushL(entry);
+ // get the version
+ TVersion packageVersion = entry.VersionL();
+ INFO_PRINTF4(_L("Version %d %d %d"), packageVersion.iMajor, packageVersion.iMinor, packageVersion.iBuild );
+
+ // get sids
+ RArray<TUid> sids;
+ CleanupClosePushL(sids);
+ entry.SidsL(sids);
+ if (sids.Count() <= 0)
+ {
+ INFO_PRINTF1(_L("No sids installed!"));
+ }
+ else
+ {
+ for (TInt sid = 0; sid < sids.Count(); sid++)
+ {
+ INFO_PRINTF2(_L("Sid: 0x%08x was found!"), sids[sid]);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&sids);
+
+ // get the vendor; package name
+ HBufC* reportedVendor = entry.UniqueVendorNameL();
+ CleanupStack::PushL(reportedVendor);
+ HBufC* reportedPackage = entry.PackageNameL();
+ CleanupStack::PushL(reportedPackage);
+
+ INFO_PRINTF3(_L("Package: %S from Vendor: %S"), reportedPackage, reportedVendor);
+
+ CleanupStack::PopAndDestroy(reportedPackage);
+ CleanupStack::PopAndDestroy(reportedVendor);
+
+ // get the localised vendor name
+ HBufC* vendorLocal = entry.LocalizedVendorNameL();
+ CleanupStack::PushL(vendorLocal);
+ INFO_PRINTF2(_L("Localised Vendor Name: %S"), vendorLocal);
+
+ CleanupStack::PopAndDestroy(vendorLocal);
+
+ // get uid
+ TUid uid = entry.UidL();
+ INFO_PRINTF3(_L("Package Uid: %d 0x%08x"), uid.iUid, uid.iUid);
+
+ // get language
+ TLanguage language = entry.LanguageL();
+ INFO_PRINTF3(_L("Package Language: %d 0x%08x"), language, language);
+
+ // get property
+ TInt32 propertyKey = 10;
+ TInt32 propertyValue = entry.PropertyL(propertyKey);
+ INFO_PRINTF3(_L("Package property: key %d value %d"), propertyKey, propertyValue);
+
+ // is present - currenty relies on default value
+ TBool isPresent = entry.IsPresentL();
+ INFO_PRINTF2(_L("Package present is %d"), isPresent);
+
+ // is signed
+ TBool isSigned = entry.IsSignedL();
+ INFO_PRINTF2(_L("Package signed is %d"), isSigned);
+
+
+ // check Trust
+ switch(entry.TrustL())
+ {
+ case ESisPackageUnsignedOrSelfSigned:
+ INFO_PRINTF1(_L("Packaged Trust: Unsigned or self signed"));
+ break;
+ case ESisPackageCertificateChainNoTrustAnchor:
+ INFO_PRINTF1(_L("Packaged Trust: Certificate Chain has no trust anchor in Cert store"));
+ break;
+ case ESisPackageCertificateChainValidatedToTrustAnchor:
+ INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validated to Trust Anchor in Cert store"));
+ break;
+ case ESisPackageChainValidatedToTrustAnchorOCSPTransientError:
+ INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validated and OCSP Transient Error"));
+ break;
+ case ESisPackageChainValidatedToTrustAnchorAndOCSPValid:
+ INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validated and OCSP Valid"));
+ break;
+ case ESisPackageBuiltIntoRom:
+ INFO_PRINTF1(_L("Packaged Trust: Built into ROM"));
+ break;
+ case ESisPackageValidationFailed:
+ INFO_PRINTF1(_L("Packaged Trust: Certificate Chain Validation Failed"));
+ break;
+ default:
+ INFO_PRINTF1(_L("Packaged Trust: Unknown"));
+ break;
+ };
+
+ // Time at which the trust was established
+ TTime timeStamp = entry.TrustTimeStampL();
+ TBuf <32> dateTimeText;
+ TRAP_IGNORE(timeStamp.FormatL(dateTimeText, _L("%H%:1%T%:2%S on %1%/1%2%/2%3")));
+ INFO_PRINTF2(_L("Package Trust Established: %S"), &dateTimeText);
+
+ // is in rom
+ TBool inRom = entry.IsInRomL();
+ INFO_PRINTF2(_L("Package inRom is %d"), inRom);
+
+ // is an augmentation
+ TBool isAug = entry.IsAugmentationL();
+ INFO_PRINTF2(_L("Package isAug is %d"), isAug);
+
+ // installation size
+ TInt64 size = entry.SizeL();
+ INFO_PRINTF3(_L("Package size is %d %d"), I64HIGH(size), I64LOW(size));
+
+ // get list of files
+ RPointerArray<HBufC> files;
+ CleanupResetAndDestroy<RPointerArray<HBufC> >::PushL(files);
+ entry.FilesL(files);
+ INFO_PRINTF2(_L("Package has %d files"), files.Count());
+ for (TInt file = 0; file < files.Count(); file++)
+ {
+ // INFO_PRINTF3(_L("File %d file path %S"),file + 1, files[file]);
+ }
+ CleanupStack::PopAndDestroy(&files);
+
+ CleanupStack::PopAndDestroy(&entry);
+ }
+
+ CleanupStack::PopAndDestroy(&packages);
+
+ return TestStepResult();
+ }
+
+
+/////////////////////////////////////////////////////////////////////
+// CEntrySidsStep - obtain a list of Sids from an entry
+/////////////////////////////////////////////////////////////////////
+CEntrySidsStep::CEntrySidsStep()
+ {
+ SetTestStepName(KEntrySids);
+ }
+
+TVerdict CEntrySidsStep::doTestStepL()
+ {
+ SetTestStepResult(EFail);
+
+ RArray<TUid> expectedSids;
+ CleanupClosePushL(expectedSids);
+ GetUidArrayFromConfigL(ConfigSection(), KSid, expectedSids);
+
+ TPtrC package;
+ TPtrC vendor;
+ if(GetStringFromConfig(ConfigSection(), KPackage, package)
+ && GetStringFromConfig(ConfigSection(), KVendor, vendor))
+ {
+ Swi::RSisRegistryEntry entry;
+ User::LeaveIfError(entry.Open(iSisRegistry, package, vendor));
+ CleanupClosePushL(entry);
+
+ RArray<TUid> sids;
+ CleanupClosePushL(sids);
+ entry.SidsL(sids);
+
+ if (sids.Count() != expectedSids.Count())
+ {
+ ERR_PRINTF3(_L("Actual Sids = %d, Expected Sids = %d"), sids.Count(), expectedSids.Count());
+ }
+ else
+ {
+ SetTestStepResult(EPass);
+ for (TInt index=0; index < expectedSids.Count(); index++)
+ {
+ if(sids.Find(expectedSids[index]) != KErrNotFound)
+ {
+ INFO_PRINTF2(_L("Sid: 0x%08x was found!"), expectedSids[index]);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ ERR_PRINTF2(_L("Sid: 0x%08x not found!"), expectedSids[index]);
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(&sids);
+ CleanupStack::PopAndDestroy(&entry);
+ }
+
+ CleanupStack::PopAndDestroy(&expectedSids);
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CIsSidPresentStep - test package SIDs are reported as present.
+/////////////////////////////////////////////////////////////////////
+
+CIsSidPresentStep::CIsSidPresentStep()
+ {
+ SetTestStepName(KIsSidPresentStep);
+ }
+
+TVerdict CIsSidPresentStep::doTestStepL()
+ {
+ // iterate through every sid which is installed in a package
+ RPointerArray<CSisRegistryPackage> packages;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryPackage> >::PushL(packages);
+
+ iSisRegistry.InstalledPackagesL(packages);
+
+ TInt32 minSid = KMaxTInt32;
+ TInt32 maxSid = KMinTInt32;
+
+ for (TInt i = packages.Count() - 1; i >= 0; --i)
+ {
+ const CSisRegistryPackage& pkg = *packages[i];
+
+ Swi::RSisRegistryEntry e;
+ TInt r = e.Open(iSisRegistry, pkg.Uid());
+ User::LeaveIfError(r);
+ CleanupClosePushL(e);
+
+ RArray<TUid> sids;
+ e.SidsL(sids);
+ CleanupClosePushL(sids);
+
+ for (TInt j = sids.Count() - 1; j >= 0; --j)
+ {
+ TUid sid = sids[j];
+ minSid = Min(minSid, sid.iUid);
+ maxSid = Max(maxSid, sid.iUid);
+
+ TBool sidPresent = iSisRegistry.IsSidPresentL(sid);
+ TESTL(sidPresent);
+ }
+
+ CleanupStack::PopAndDestroy(2, &e);
+ }
+
+ TUid minSidM1(TUid::Uid(minSid - 1));
+ TESTL(! iSisRegistry.IsSidPresentL(minSidM1));
+ TUid maxSidP1(TUid::Uid(minSid + 1));
+ TESTL(! iSisRegistry.IsSidPresentL(maxSidP1));
+
+ CleanupStack::PopAndDestroy(&packages);
+
+ SetTestStepResult(EPass);
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CIsPackagePresentStep - Test the IsPresent method
+/////////////////////////////////////////////////////////////////////
+
+CIsPackagePresentStep::CIsPackagePresentStep()
+ {
+ SetTestStepName(KIsPackagePresentStep);
+ }
+
+TVerdict CIsPackagePresentStep::doTestStepL()
+ {
+ SetTestStepResult(EPass);
+
+ RArray<TUid> pUids;
+ CleanupClosePushL(pUids);
+ GetUidArrayFromConfigL(ConfigSection(), KUid, pUids);
+
+ TInt count(pUids.Count());
+ for (TInt i = 0; i < count; ++i)
+ {
+ // before each step, reset the registry state
+
+ RTestUtilSessionSwi util;
+ User::LeaveIfError(util.Connect());
+ CleanupClosePushL(util);
+ util.RegenerateRegistryCacheL();
+ CleanupStack::PopAndDestroy(&util);
+
+ // query the registry to see if this entry is present
+ RSisRegistryEntry entry;
+ //Since the SisRegistry is inconsistent from hardware and emulator, we won't check
+ //whether a package is presented on device if it's not installed at all thus no registry entry (e.g. MIDP)
+ #ifdef __WINS__
+ User::LeaveIfError(entry.Open(iSisRegistry, pUids[i]));
+ #else
+ TInt err = entry.Open(iSisRegistry, pUids[i]);
+ if(KErrNotFound == err)
+ {
+ INFO_PRINTF2(_L("Package with UID 0x%08x is not installed on HW. IsPresent test skipped"),
+ pUids[i]);
+ continue;
+ }
+ User::LeaveIfError(err);
+ #endif
+ CleanupClosePushL(entry);
+
+ if (!entry.IsPresentL())
+ {
+ INFO_PRINTF2(_L("Package with UID 0x%08x is marked as not present!"),
+ pUids[i]);
+ SetTestStepResult(EFail);
+ }
+
+ CleanupStack::PopAndDestroy(&entry);
+ }
+ CleanupStack::PopAndDestroy(&pUids);
+ return TestStepResult();
+ }
+CIntegrityCheckStep::CIntegrityCheckStep()
+ {
+ SetTestStepName(KIntegrityCheckStep);
+ }
+CIntegrityCheckStep::~CIntegrityCheckStep()
+ {
+ }
+
+TVerdict CIntegrityCheckStep::doTestStepL()
+ {
+ TInt result=0;
+
+
+ CleanupResetAndDestroy<RPointerArray<CX509Certificate> >::PushL(iCertArray);
+
+ InitializeL();
+ TUid pUid;
+ GetUidFromConfig(ConfigSection(), KUid, pUid);
+ GetIntFromConfig(ConfigSection(),KResultTag,result);
+
+ RSisRegistryEntry entry;
+
+ SetTestStepResult(EFail);
+
+
+ // query the registry to see if this entry is present
+ User::LeaveIfError (entry.Open(iSisRegistry, pUid));
+
+ //Call the controller
+ TBool check = EFalse;
+
+ check = entry.VerifyControllerSignatureL(iCertArray);
+
+ if(check!=result)
+ {
+ SetTestStepResult(EFail);
+ }
+ else
+ {
+ SetTestStepResult(EPass);
+ }
+ entry.Close();
+ CleanupStack::PopAndDestroy(&iCertArray);
+ return TestStepResult();
+ }
+
+void CIntegrityCheckStep::InitializeL()
+ {
+ CX509Certificate* cert = NULL;
+ RArray<TPtrC> rootCertificates;
+ CleanupClosePushL(rootCertificates);
+ GetStringArrayFromConfigL(ConfigSection(), KRootCertTag, rootCertificates);
+
+ User::LeaveIfError (fs.Connect());
+ //opens the data file
+ CleanupClosePushL(fs);
+
+ //Loop through all the X509 root certificates and load them
+ for (TInt i=0; i<rootCertificates.Count(); i++)
+ {
+ HBufC8* rawData = ReadFileLC(rootCertificates[i]);
+ cert = CX509Certificate::NewL(*rawData);
+ CleanupStack::PopAndDestroy(rawData);
+ CleanupStack::PushL(cert);
+ iCertArray.AppendL(cert);
+ CleanupStack::Pop();
+ }
+
+ //closes the file session
+ CleanupStack::PopAndDestroy(&fs);
+ CleanupStack::PopAndDestroy(&rootCertificates);
+ }
+
+HBufC8* CIntegrityCheckStep::ReadFileLC(const TDesC& aDatapath)
+ {
+ RFile file;
+ User::LeaveIfError(file.Open(fs, aDatapath, EFileRead)) ;
+
+ TInt fileSize = 0;
+ User::LeaveIfError(file.Size(fileSize));
+
+ HBufC8* rawData = HBufC8::NewLC(fileSize);
+ TPtr8 rawDataPtr(rawData->Des());
+ rawDataPtr.SetLength(fileSize);
+ file.Read (rawDataPtr);
+
+ file.Close();
+
+ return rawData;
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CIntegrityDateAndTimeCheckStep -
+/////////////////////////////////////////////////////////////////////
+
+
+CIntegrityDateAndTimeCheckStep::CIntegrityDateAndTimeCheckStep()
+ {
+ SetTestStepName(KDateAndTimeIntegrityCheckStep);
+ }
+
+
+TVerdict CIntegrityDateAndTimeCheckStep::doTestStepPreambleL()
+ {
+ CIntegrityCheckStep::doTestStepPreambleL();
+
+ GetUidFromConfig(ConfigSection(), KUid, iPackageUid);
+ GetIntFromConfig(ConfigSection(),KResultTag,iExpectedResult);
+
+ TPtrC dateAndTime;
+ GetStringFromConfig(ConfigSection(), KDateTime, dateAndTime);
+ iTime = TTime(dateAndTime);
+
+ iOriginalTime.UniversalTime();
+ User::SetUTCTime(iTime);
+
+ return EPass;
+ }
+
+TVerdict CIntegrityDateAndTimeCheckStep::doTestStepPostambleL()
+ {
+ TTime timeNow;
+ timeNow.UniversalTime();
+
+ TTimeIntervalMicroSeconds timeInterval = timeNow.MicroSecondsFrom(iTime);
+ timeNow = iOriginalTime + timeInterval;
+
+ User::SetUTCTime(timeNow);
+
+ return TestStepResult();
+ }
+
+TVerdict CIntegrityDateAndTimeCheckStep::doTestStepL()
+ {
+ CleanupResetAndDestroy<RPointerArray<CX509Certificate> >::PushL(iCertArray);
+
+ InitializeL();
+
+ RSisRegistryEntry entry;
+
+ SetTestStepResult(EPass);
+ // query the registry to see if this entry is present
+ User::LeaveIfError(entry.Open(iSisRegistry, iPackageUid));
+ CleanupClosePushL(entry);
+
+ //Call the controller
+ TBool check = EFalse;
+
+ check = entry.VerifyControllerSignatureL(iCertArray, ETrue);
+ if(check!=iExpectedResult)
+ {
+ ERR_PRINTF3(_L("ERROR: First call to verify failed. Result: %d. Expected Result: %d"), check, iExpectedResult);
+ SetTestStepResult(EFail);
+ }
+
+ check = entry.VerifyControllerSignatureL(iCertArray, EFalse);
+ if(check==EFalse)
+ {
+ ERR_PRINTF2(_L("ERROR: Second call to verify failed. Result: %d. Expected Result: ETrue"), check);
+ SetTestStepResult(EFail);
+ }
+
+ check = entry.VerifyControllerSignatureL(iCertArray, ETrue);
+ if(check!=iExpectedResult)
+ {
+ ERR_PRINTF3(_L("ERROR: Third call to verify failed. Result: %d. Expected Result: %d"), check, iExpectedResult);
+ SetTestStepResult(EFail);
+ }
+
+ CleanupStack::PopAndDestroy(2, &iCertArray);
+
+ return TestStepResult();
+ }
+
+
+/////////////////////////////////////////////////////////////////////
+// CLoggingFileInfoStep -
+/////////////////////////////////////////////////////////////////////
+
+CLoggingFileInfoStep::CLoggingFileInfoStep()
+ {
+ SetTestStepName(KLoggingFileInfo);
+ }
+
+TVerdict CLoggingFileInfoStep::doTestStepL()
+ {
+ SetTestStepResult(EPass);
+ __UHEAP_MARK;
+ RPointerArray<CLogEntry> fileInfo;
+ CleanupResetAndDestroy<RPointerArray<CLogEntry> >::PushL(fileInfo);
+ iSisRegistry.RetrieveLogFileL(fileInfo);
+
+ if (fileInfo.Count()>0)
+ {
+ for (TInt i = 0; i < 5; i++)
+ {
+ TInt var = 1;
+ TBuf<16> entry;
+ entry.Format(_L("LOGENTRY%d.%d"),i,var);
+ TPtrC text0;
+ GetStringFromConfig(ConfigSection(), entry, text0);
+ entry.Format(_L("LOGENTRY%d.%d"),i,++var);
+ TPtrC text1;
+ GetStringFromConfig(ConfigSection(), entry, text1);
+ entry.Format(_L("LOGENTRY%d.%d"),i,++var);
+ TPtrC text2;
+ GetStringFromConfig(ConfigSection(), entry, text2);
+ entry.Format(_L("LOGENTRY%d.%d"),i,++var);
+ TPtrC text3;
+ GetStringFromConfig(ConfigSection(), entry, text3);
+
+ TBuf<16> pkgName = fileInfo[0]->GetPkgName();
+ TBuf<20> versiontext;
+ versiontext.Format(_L("%d.%d.%d"),fileInfo[i]->GetMajorVersion(),fileInfo[i]->GetMinorVersion(),fileInfo[i]->GetBuildVersion());
+
+ enum Swi::TSwiLogTypes s = fileInfo[i]->GetInstallType();
+ TBuf<16> installType ;
+ switch (s)
+ {
+ case 0: // Swi::TSwiLogTypes::ESwiLogInstall :
+ installType.Format(_L("Install"));
+ break;
+ case 1:
+ installType.Format(_L("UnInstall"));
+
+ break;
+ case 2: // Swi::TSwiLogTypes::ESwiLogUpgrade :
+ installType.Format(_L("Upgrade"));
+
+ break;
+ default:
+ installType.Format(_L("Error unknown value"));
+
+ break;
+ }
+
+ TBuf<16> uidOfPkg;
+ uidOfPkg.Format(_L("%x"),fileInfo[i]->GetUid());
+
+ if(pkgName == text0 && versiontext == text1
+ && installType ==text2 && uidOfPkg ==text3)
+ {
+ SetTestStepResult(EPass);
+ }
+ else
+ {
+ SetTestStepResult(EFail);
+ }
+ }
+ }
+ else
+ {
+ SetTestStepResult(EPass);
+ }
+ CleanupStack::PopAndDestroy(&fileInfo);
+ __UHEAP_MARKEND;
+ return TestStepResult();
+ }
+
+CRomStubPerformanceStep::CRomStubPerformanceStep()
+ {
+ SetTestStepName(KRomStubPerformanceStep);
+ }
+
+TVerdict CRomStubPerformanceStep::doTestStepL()
+ {
+ // Simple test step to determine how long it takes to
+ // regenerate the cache.
+
+ // Make sure the sisregistry is deleted before regenerating the cache. This
+ // will ensure that the registry entries are created from the ROM stub, instead
+ // of being read from the harddisk
+ RTestUtilSessionSwi util;
+ User::LeaveIfError(util.Connect());
+ CleanupClosePushL(util);
+
+ TDriveUnit sysDrive (RFs::GetSystemDrive());
+ TBuf<128> sisRegistryPath (sysDrive.Name());
+ sisRegistryPath.Append(KSisRegistryPath);
+
+ TInt err = util.RmDir(sisRegistryPath);
+ if(err != KErrNone && err != KErrPathNotFound && err != KErrNotFound)
+ {
+ User::Leave(err);
+ }
+ else
+ {
+ INFO_PRINTF1(_L("Sis Registry Deleted!"));
+ }
+
+ INFO_PRINTF1(_L("Regenerate the cache. Starting the timer..."));
+ TTime startTime;
+ startTime.UniversalTime();
+
+ RTestUtilSessionSwi utilswi;
+ User::LeaveIfError(utilswi.Connect());
+ CleanupClosePushL(utilswi);
+
+ utilswi.RegenerateRegistryCacheL();
+
+ // Stop the timer
+ TTime endTime;
+ endTime.UniversalTime();
+ INFO_PRINTF1(_L("Cache regenerated. Timer stopped."));
+
+ TInt64 durationMicro=endTime.MicroSecondsFrom(startTime).Int64();
+ TInt durationMilli=durationMicro/1000;
+
+ INFO_PRINTF2(_L("Duration (milliseconds): %d"),durationMilli);
+
+ CleanupStack::PopAndDestroy(&utilswi);
+ CleanupStack::PopAndDestroy(&util);
+
+ SetTestStepResult(EPass);
+
+ return TestStepResult();
+ }
+
+//////////////////////////////////////////////////////////////
+// CCorruptCacheStep - The Sis Registry will leave backup.bak
+// around when it encounters a corrupt cache file
+//////////////////////////////////////////////////////////////
+
+CCorruptCacheStep::CCorruptCacheStep()
+ {
+ SetTestStepName(KCorruptCacheStep);
+ }
+
+TVerdict CCorruptCacheStep::doTestStepL()
+ {
+ SetTestStepResult(EFail);
+
+ __UHEAP_MARK;
+
+ RTestUtilSessionSwi util;
+ User::LeaveIfError(util.Connect());
+ CleanupClosePushL(util);
+ TDriveUnit sysDrive (RFs::GetSystemDrive());
+ TDriveName sysDriveName (sysDrive.Name());
+
+ // Close the Sis Registry and wait for 3 secs for
+ // server to shut down
+ iSisRegistry.Close();
+
+ INFO_PRINTF1(_L("Sis Registry shut down"));
+ User::After(3000000);
+
+ // Delete the "good" backup.lst (if present)
+ TInt err = util.Delete(KCacheBackupFile);
+
+ if (err == KErrNone)
+ {
+ INFO_PRINTF2(_L("Deleted '%S'"), &KCacheBackupFile);
+ }
+
+ // Use hashforlang_txt.dat as a corrupt backup.lst and connect to the
+ // Sis Registry.
+ util.Copy(KCorruptCacheBackupFile, KCacheBackupFile);
+
+ INFO_PRINTF3(_L("Copied '%S' to '%S'"), &KCorruptCacheBackupFile, &KCacheBackupFile);
+
+ INFO_PRINTF1(_L("Connecting to SisRegistry..."));
+
+ RProcess sisRegistryServer;
+ TInt retVal = sisRegistryServer.Create(_L("SisRegistryServer"),KNullDesC);
+
+ if (retVal == KErrNone)
+ {
+ TRequestStatus status;
+ sisRegistryServer.Logon(status);
+ sisRegistryServer.Resume();
+ User::WaitForRequest(status);
+
+ TExitCategoryName panicName = sisRegistryServer.ExitCategory();
+ TPtrC name(panicName);
+ TInt reasonNumber = sisRegistryServer.ExitReason();
+
+ if (reasonNumber == 0 && name.Compare(_L("Kill")) == KErrNone)
+ {
+ if (util.FileExistsL(KSysBackupFileBackup))
+ {
+ if (util.FileExistsL(KCacheBackupFile))
+ {
+ INFO_PRINTF4(_L("'%S' and '%S' exist in System Drive: %S\\"),
+ &KSysBackupFileBackup, &KCacheBackupFile, &sysDriveName);
+ SetTestStepResult(EPass);
+ }
+ else
+ {
+ INFO_PRINTF3(_L("Expecting '%S' exist in System Drive: %S\\ but not found"),
+ &KCacheBackupFile, &sysDriveName);
+ }
+ }
+ else
+ {
+ INFO_PRINTF3(_L("Expecting '%S' exist in System Drive: %S\\ but not found"),
+ &KSysBackupFileBackup, &sysDriveName);
+ }
+ }
+
+ INFO_PRINTF3(_L("CCorruptCacheStep - Exit Reason Number: %d Exit Reason Code: %S"),
+ reasonNumber, &name);
+ }
+
+ sisRegistryServer.Terminate(0);
+ sisRegistryServer.Close();
+
+ CleanupStack::PopAndDestroy(&util);
+
+ __UHEAP_MARKEND;
+
+ return TestStepResult();
+ }
+
+////////////////////////////////////////////////////////////////
+// CCorruptCacheRecoverStep - Checks to see if the Sis Registry
+// recovers from a corrupt token cache file
+////////////////////////////////////////////////////////////////
+
+CCorruptCacheRecoverStep::CCorruptCacheRecoverStep()
+ {
+ SetTestStepName(KCorruptCacheRecoverStep);
+ }
+
+TVerdict CCorruptCacheRecoverStep::doTestStepL()
+ {
+ SetTestStepResult(EFail);
+
+ RTestUtilSessionSwi util;
+ User::LeaveIfError(util.Connect());
+ CleanupClosePushL(util);
+ TDriveUnit sysDrive (RFs::GetSystemDrive());
+ TDriveName sysDriveName (sysDrive.Name());
+
+ // Close the Sis Registry and wait for 3 secs for
+ // the server to shut down
+ iSisRegistry.Close();
+ INFO_PRINTF1(_L("Sis Registry shut down"));
+ User::After(3000000);
+
+ // Attempt to read from the token cache file
+ RFs fs;
+ User::LeaveIfError(fs.Connect());
+ CleanupClosePushL(fs);
+
+ RFileReadStream stream;
+ User::LeaveIfError(stream.Open(fs, KCacheBackupFile, EFileRead | EFileShareReadersOnly));
+ CleanupClosePushL(stream);
+
+ INFO_PRINTF2(_L("'%S' regenerated successfully. Check by reading and internalizing..."), &KCacheBackupFile);
+
+ RPointerArray<CSisRegistryToken> tokens;
+ CleanupResetAndDestroy<RPointerArray<CSisRegistryToken> >::PushL(tokens);
+
+ // Will not catch a panic, but still a worthwhile check to make
+ TRAPD(err, stream.ReadUint32L());
+ TRAP(err, InternalizePointerArrayL(tokens, stream));
+
+ if (err == KErrNone)
+ {
+ INFO_PRINTF2(_L("'%S' successfully read!"), &KCacheBackupFile);
+
+ if (!util.FileExistsL(KSysBackupFileBackup))
+ {
+ if (util.FileExistsL(KCacheBackupFile))
+ {
+ INFO_PRINTF3(_L("'%S' exist in System Drive: %S\\"),
+ &KCacheBackupFile, &sysDriveName);
+
+ SetTestStepResult(EPass);
+ }
+ else
+ {
+ INFO_PRINTF3(_L("Expecting '%S' exist in System Drive: %S\\ but not found"),
+ &KCacheBackupFile, &sysDriveName);
+ }
+ }
+ else
+ {
+ INFO_PRINTF3(_L("'%S' exist in System Drive: %S\\ but shouldn't"),
+ &KSysBackupFileBackup, &sysDriveName);
+ }
+ }
+
+ CleanupStack::PopAndDestroy(4, &util);
+
+ return TestStepResult();
+ }
+
+/////////////////////////////////////////////////////////////////////
+// CChangeLocaleStep - Changes the locale
+/////////////////////////////////////////////////////////////////////
+
+CChangeLocaleStep::CChangeLocaleStep()
+ {
+ SetTestStepName(KChangeLocale);
+ }
+
+TVerdict CChangeLocaleStep::doTestStepL()
+ {
+ SetTestStepResult(EFail);
+
+ TInt language=0;
+ if (!GetIntFromConfig(ConfigSection(), KLanguage, language))
+ {
+ INFO_PRINTF1(_L("Missing language in config section"));
+ return EFail;
+ }
+
+ #ifdef SYMBIAN_DISTINCT_LOCALE_MODEL
+ _LIT(KLitLanguageLocaleDllNameBase, "elocl_lan");
+ //Region and collation code values are hard coded, as the check, after changing the locale is made for the language only.
+ _LIT(KLitRegionLocaleDllNameBase, "elocl_reg.826");
+ _LIT(KLitCollationLocaleDllNameBase, "elocl_col.001");
+ _LIT(ThreeDigExt,".%03d");
+
+ TExtendedLocale localeDll;
+ const TUidType uidType(TUid::Uid(0x10000079),TUid::Uid(0x100039e6));
+ TBuf<16> languageLocaleDllName(KLitLanguageLocaleDllNameBase);
+ languageLocaleDllName.AppendFormat(ThreeDigExt, language);
+ TBuf<16> regionLocaleDllName(KLitRegionLocaleDllNameBase);
+ TBuf<16> collationLocaleDllName(KLitCollationLocaleDllNameBase);
+ // Try to load the locale dll
+ TInt error=localeDll.LoadLocale(languageLocaleDllName, regionLocaleDllName, collationLocaleDllName);
+
+ if (error==KErrNotFound)
+ {
+ // Locale dll is not found for the asked language.
+ ERR_PRINTF2(_L("Failed to find the locale dll for %d"), language);
+ }
+
+ User::LeaveIfError(error);
+ localeDll.SaveSystemSettings();
+
+ #else
+ _LIT(KLitLocaleDllNameBase, "ELOCL");
+ _LIT(TwoDigExt,".%02d");
+
+ RLibrary localeDll;
+ CleanupClosePushL(localeDll);
+
+ const TUidType uidType(TUid::Uid(0x10000079),TUid::Uid(0x100039e6));
+ TBuf<16> localeDllName(KLitLocaleDllNameBase);
+ localeDllName.AppendFormat(TwoDigExt, language);
+
+ // Try to load the locale dll
+ TInt error=localeDll.Load(localeDllName, uidType);
+ if (error==KErrNotFound)
+ {
+ // Locale dll is not found for the asked language.
+ ERR_PRINTF2(_L("Failed to find the locale dll for %d"), language);
+ }
+
+ User::LeaveIfError(error);
+ User::LeaveIfError(UserSvr::ChangeLocale(localeDllName));
+ CleanupStack::PopAndDestroy(); // localeDll
+ #endif
+
+ // Check if the device locale has changed
+ if (language == User::Language())
+ {
+ SetTestStepResult(EPass);
+ }
+ else
+ {
+ ERR_PRINTF3(_L("Failed to change the locale to %d whereas the current locale is"), language, User::Language());
+ }
+
+ return TestStepResult();
+ }
+
+
+