diff -r 000000000000 -r ba25891c3a9e installationservices/swi/test/swicaptests/registrycaptest.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/installationservices/swi/test/swicaptests/registrycaptest.cpp	Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,599 @@
+/*
+* Copyright (c) 2005-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
+*/
+
+#include "registrycaptest.h"
+
+#include "sisregistrywritablesession.h"
+#include "sisregistrywritableentry.h"
+#include "sisregistrysession.h"
+#include "sisregistrypackage.h"
+#include "sisregistryentry.h"
+#include "sisrevocationentry.h"
+#include "sisregistryserver.h"
+#include "application.h"
+#include "sistruststatus.h"
+#include "sisregistryfiledescription.h"
+#include "sisregistrydependency.h"
+#include "userselections.h"
+#include "siscontroller.h"
+#include "filesisdataprovider.h"
+#include "dessisdataprovider.h"
+#include "cleanuputils.h"
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+#include "swtypereginfo.h"
+#endif
+#include <e32def.h>
+#include <f32file.h>
+
+using namespace Swi;
+
+_LIT(KPublicRegistryCapTestName, "Registry public (no caps) interface capability test");
+_LIT(KReadUserDataRegistryCapTestName, "Registry public (ReadUserData) interface capability test");
+_LIT(KPrivateRegistryCapTestName, "Registry private interface capability test");
+_LIT(KDaemonRegistryCapTestName, "Registry daemon interface capability test");
+_LIT(KRevocationRegistryCapTestName, "Registry revocation interface capability test");
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+_LIT(KSifServerRegistryCapTestName, "Registry SIF interface security test");
+#endif
+
+CPublicRegistryCapTest* CPublicRegistryCapTest::NewL()
+	{
+	CPublicRegistryCapTest* self=new(ELeave) CPublicRegistryCapTest();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CPublicRegistryCapTest::CPublicRegistryCapTest()
+	{
+	}
+	
+void CPublicRegistryCapTest::ConstructL()
+	{
+	SetNameL(KPublicRegistryCapTestName);
+	}
+
+void CPublicRegistryCapTest::RunTestL()
+	{
+	Swi::RSisRegistrySession session;
+	CleanupClosePushL(session);
+		
+	TInt err = session.Connect();
+	
+	if (KErrNone != err)
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+
+	// RSisregistryEntry
+	Swi::RSisRegistryEntry entry;
+	
+// open an entry to do tests on
+	TUid uid = { 0x101f7989}; // Package known to exist
+	if (KErrNone != CheckFailL(entry.Open(session, uid), _L("Open(TUid)")))
+		{
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+	CleanupClosePushL(entry);
+	
+	TRAP(err, entry.IsSignedL());
+	CheckFailL(err, _L("RSisregistryEntry::IsSignedL"));
+
+	TRAP(err, entry.IsInRomL());
+	CheckFailL(err, _L("RSisregistryEntry::IsInRomL"));
+	
+	TRAP(err, entry.VersionL());
+	CheckFailL(err, _L("RSisregistryEntry::VersionL"));
+
+	TRAP(err, entry.LanguageL());
+	CheckFailL(err, _L("RSisregistryEntry::LanguageL"));
+
+	TRAP(err, entry.SelectedDriveL());
+	CheckFailL(err, _L("SelectedDriveL"));
+
+	TRAP(err, entry.TrustStatusL());
+	CheckFailL(err, _L("RSisregistryEntry::TrustStatusL"));
+
+	HBufC* name=NULL;
+	TRAP(err, name = entry.PackageNameL());
+	CleanupStack::PushL(name);
+	CheckFailL(err, _L("RSisregistryEntry::PackageNameL"));
+	CleanupStack::PopAndDestroy(name);
+	
+	TRAP(err, name= entry.UniqueVendorNameL());
+	CleanupStack::PushL(name);
+	CheckFailL(err, _L("RSisregistryEntry::UniqueVendorNameL"));
+	CleanupStack::PopAndDestroy(name);
+	
+	TRAP(err, entry.LocalizedVendorNameL());
+	CheckFailL(err, _L("RSisregistryEntry::LocalizedVendorNameL"));
+
+
+	RPointerArray<HBufC8> chains;
+	TRAP(err, entry.CertificateChainsL(chains));
+	CleanupResetAndDestroyPushL(chains);
+	CheckFailL(err, _L("RSisregistryEntry::CertificateChainsL"));
+	CleanupStack::PopAndDestroy(&chains);
+
+	TRAP(err, entry.PropertyL(0));
+	CheckFailL(err, _L("RSisregistryEntry::PropertyL"));
+
+	Swi::CSisRegistryPackage* package=NULL;
+	TRAP(err, package=entry.PackageL());
+	delete package;
+	CheckFailL(err, _L("RSisregistryEntry::PackageL"));
+
+	RPointerArray<HBufC8> controllers;
+	TRAP(err, entry.ControllersL(controllers));
+	CleanupResetAndDestroyPushL(controllers);
+	CheckFailL(err, _L("RSisregistryEntry::ControllersL"));
+	CleanupStack::PopAndDestroy(&controllers);
+	
+	TUid nonExistentUid ={0};
+	TRAP(err, session.IsInstalledL(nonExistentUid));
+	CheckFailL(err, _L("RSisRegistrySession::IsInstalledL(TUid)"));
+
+	TBuf8<5> controller;
+	TRAP(err, session.IsInstalledL(controller));
+	CheckFailL(err, _L("RSisRegistrySession::IsInstalledL(TDesC8&)"));
+
+// These two are unimplemented in the server
+//	TRAP(err, session.HashL(_L("C:\\a filename.txt")));
+//	CheckFailL(err, _L("RSisRegistrySession::HashL"));
+//	TRAP(err, session.ModifiableL(_L("C:\\a filename.txt")));
+//	CheckFailL(err, _L("RSisRegistrySession::ModifiableL"));
+
+	TUid sid={0};
+	TRAP(err, session.SidToPackageL(sid));
+	CheckFailL(err, _L("RSisRegistrySession::SidToPackageL"));
+	
+	TRAP(err, entry.RemovableL());
+	CheckFailL(err, _L("RSisregistryEntry::RemovableL"));	
+
+#ifdef 	SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+	TRAP(err, session.IsFileRegisteredL(_L("some.file")));
+	CheckFailL(err, _L("RSisregistrySession::IsFileRegisteredL"));		
+
+	TRAP(err, session.GetComponentIdForUidL(uid));
+	CheckFailL(err, _L("RSisregistrySession::GetComponentIdForUidL"));
+#endif
+
+	Swi::RSisRegistryWritableEntry writableEntry;
+	
+	TUid uidOpen = { 0x101f7989}; // Package known to exist
+	
+	if (KErrNone != writableEntry.Open(session, uidOpen))
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+
+	CleanupClosePushL(writableEntry);
+
+	RPointerArray<Swi::CSisRegistryFileDescription> fileDescriptions;
+	TRAP(err, writableEntry.FileDescriptionsL(fileDescriptions));
+	CleanupResetAndDestroyPushL(fileDescriptions);
+	CheckFailL(err, _L("FileDescriptionsL"));
+	CleanupStack::PopAndDestroy(&fileDescriptions);
+
+	TRAP(err, writableEntry.PreInstalledL());
+	CheckFailL(err, _L("PreInstalledL"));
+
+	TRAP(err, writableEntry.IsPresentL());
+	CheckFailL(err, _L("RSisregistryEntry::IsPresentL"));
+
+	TRAP(err, writableEntry.IsAugmentationL());
+	CheckFailL(err, _L("RSisregistryEntry::IsAugmentationL"));
+
+	TRAP(err, writableEntry.UidL());
+	CheckFailL(err, _L("RSisregistryEntry::UidL"));
+
+	RArray<TUid> sids;
+	TRAP(err, writableEntry.SidsL(sids));
+	CleanupClosePushL(sids);
+	CheckFailL(err, _L("RSisregistryEntry::Sids"));
+	CleanupStack::PopAndDestroy(&sids);
+
+	RPointerArray<HBufC> files;
+	TRAP(err, writableEntry.FilesL(files));
+	CleanupResetAndDestroyPushL(files);
+	CheckFailL(err, _L("RSisregistryEntry::FilesL"));
+	CleanupStack::PopAndDestroy(&files);
+
+	_LIT(KFileName ,"\\a filename.txt");
+	TDriveUnit sysDrive(RFs::GetSystemDrive());
+	TBuf<128> fileName = sysDrive.Name();
+	fileName.Append(KFileName);
+	TRAP(err, writableEntry.HashL(fileName));
+	CheckFailL(err, _L("RSisregistryEntry::HashL"));
+
+	RPointerArray<HBufC> packageNames;
+	RPointerArray<HBufC> vendorNames;
+	TRAP(err, writableEntry.AugmentationsL(packageNames, vendorNames));
+	CleanupResetAndDestroyPushL(vendorNames);
+	CleanupResetAndDestroyPushL(packageNames);
+	CheckFailL(err, _L("RSisregistryEntry::AugmentationsL(RPointerArray<HBufC>&,RPointerArray<HBufC>&)"));
+	CleanupStack::PopAndDestroy(&packageNames);
+	CleanupStack::PopAndDestroy(&vendorNames);
+
+	RPointerArray<Swi::CSisRegistryPackage> packages;
+	CleanupResetAndDestroyPushL(packages);
+	TRAP(err, writableEntry.AugmentationsL(packages));
+	CheckFailL(err, _L("RSisregistryEntry::AugmentationsL(RPointerArray<CSisRegistryPackage>&)"));
+	CleanupStack::PopAndDestroy(&packages);
+
+	TRAP(err, writableEntry.SizeL());
+	CheckFailL(err, _L("RSisregistryEntry::SizeL"));	
+	
+	CleanupStack::PopAndDestroy(3, &session);
+	}
+
+CReadUserDataRegistryCapTest* CReadUserDataRegistryCapTest::NewL()
+	{
+	CReadUserDataRegistryCapTest* self=new(ELeave) CReadUserDataRegistryCapTest();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CReadUserDataRegistryCapTest::CReadUserDataRegistryCapTest()
+	{
+	SetCapabilityRequired(ECapabilityReadUserData);
+	}
+	
+void CReadUserDataRegistryCapTest::ConstructL()
+	{
+	SetNameL(KReadUserDataRegistryCapTestName);
+	}
+
+void CReadUserDataRegistryCapTest::RunTestL()
+	{
+	Swi::RSisRegistrySession session;
+	CleanupClosePushL(session);
+		
+	TInt err = session.Connect();
+	
+	if (KErrNone != err)
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+	
+// RSisRegistrySession tests
+	RArray<TUid> uids;
+	TRAP(err, session.InstalledUidsL(uids));
+	CleanupClosePushL(uids);
+	CheckFailL(err, _L("RSisRegistrySession::InstalledUidsL"));
+	CleanupStack::PopAndDestroy(&uids);
+	
+	RPointerArray<Swi::CSisRegistryPackage> packages;
+	TRAP(err, session.InstalledPackagesL(packages));
+	CleanupResetAndDestroyPushL(packages);
+	CheckFailL(err, _L("RSisRegistrySession::InstalledPackagesL"));
+	CleanupStack::PopAndDestroy(&packages);
+
+	RPointerArray<Swi::CSisRegistryPackage> removablePackages;
+	TRAP(err, session.RemovablePackagesL(removablePackages));
+	CleanupResetAndDestroyPushL(removablePackages);
+	CheckFailL(err, _L("RSisRegistrySession::RemovablePackagesL"));
+	CleanupStack::PopAndDestroy(&removablePackages);
+	
+	// start debug.
+	
+	Swi::RSisRegistryWritableEntry entry;
+		
+	TUid uidOpen = {0x101f7989}; // Package known to exist
+	
+	if (KErrNone != entry.Open(session, uidOpen))
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+
+	CleanupClosePushL(entry);
+		
+	TRAP(err, entry.DependentPackagesL(packages));
+	packages.ResetAndDestroy();
+	CheckFailL(err, _L("DependentPackagesL"));
+				
+	RPointerArray<Swi::CSisRegistryDependency> dependencies;
+	TRAP(err, entry.DependenciesL(dependencies));
+	dependencies.ResetAndDestroy();
+	CheckFailL(err, _L("DependenciesL"));
+	TRAP(err, entry.EmbeddedPackagesL(packages));
+	packages.ResetAndDestroy();
+	CheckFailL(err, _L("EmbeddedPackagesL"));
+
+	TRAP(err, entry.EmbeddingPackagesL(packages));
+	packages.ResetAndDestroy();
+	CheckFailL(err, _L("EmbeddingPackagesL"));
+	
+	CleanupStack::PopAndDestroy(2, &session);
+	}
+
+
+
+CPrivateRegistryCapTest* CPrivateRegistryCapTest::NewL()
+	{
+	CPrivateRegistryCapTest* self=new(ELeave) CPrivateRegistryCapTest();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CPrivateRegistryCapTest::CPrivateRegistryCapTest()
+	{
+	SetCapabilityRequired(ECapabilityTCB);
+	SetSidRequired(Swi::KSwisSecureId);
+	}
+	
+void CPrivateRegistryCapTest::ConstructL()
+	{
+	SetNameL(KPrivateRegistryCapTestName);
+	}
+
+void CPrivateRegistryCapTest::RunTestL()
+	{
+	Swi::RSisRegistryWritableSession session;
+	CleanupClosePushL(session);
+		
+	if (KErrNone != session.Connect())
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+
+	TInt err = 0;
+
+#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+	TRAP(err, session.RegenerateCacheL());
+	CheckFailL(err, _L("RegenerateCacheL"));
+#endif
+	
+		{
+		// setup the application
+		Swi::CApplication* app=Swi::CApplication::NewLC();
+		TUint64 id=0;
+		RFs fs;
+		User::LeaveIfError(fs.Connect());
+		
+		RFile file;
+		_LIT(KControllerFile, "z:\\tswi\\swicaptests\\data\\controller");
+		User::LeaveIfError(file.Open(fs, KControllerFile, EFileRead | EFileShareReadersOnly));
+		CleanupClosePushL(file);
+		TInt fileSize;
+		User::LeaveIfError(file.Size(fileSize));
+		HBufC8* buffer = HBufC8::NewLC(fileSize);
+		TPtr8 ptr(buffer->Des());
+		User::LeaveIfError(file.Read(0, ptr, fileSize));
+	
+		// Read the controller
+		CDesDataProvider* desProvider = CDesDataProvider::NewLC(*buffer);
+		Sis::CController* controller = Sis::CController::NewL(*desProvider, Sis::EAssumeType);
+
+		app->SetInstall(*controller);
+		app->UserSelections().SetLanguage(ELangEnglish);
+		app->UserSelections().SetDrive(2);
+		
+		TRAP(err, session.AddEntryL(*app, *buffer, id));
+		CheckFailL(err, _L("AddEntryL"));
+		
+		TRAP(err, session.UpdateEntryL(*app, *buffer, id));
+		CheckFailL(err, _L("UpdateEntryL"));
+
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+		RCPointerArray<CSoftwareTypeRegInfo> regInfoArray;
+		CleanupClosePushL(regInfoArray);
+		
+		TRAP(err, session.AddEntryL(*app, *buffer, regInfoArray, id));
+		CheckFailL(err, _L("AddEntryL for LEEs"));
+		
+		TRAP(err, session.UpdateEntryL(*app, *buffer, regInfoArray, id));
+		CheckFailL(err, _L("UpdateEntryL for LEEs"));
+		
+		CleanupStack::PopAndDestroy(&regInfoArray);
+#endif
+
+		CleanupStack::PopAndDestroy(desProvider); 
+		CleanupStack::PopAndDestroy(buffer); 
+		CleanupStack::PopAndDestroy(&file); 
+		CleanupStack::PopAndDestroy(app); // app, file, buffer, desProvider, controller
+		}
+
+	Swi::RSisRegistryWritableEntry entry;
+	
+	TUid uidOpen = {0x101f7989}; // Package known to exist
+	
+	if (KErrNone != entry.Open(session, uidOpen))
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+
+	CleanupClosePushL(entry);
+
+	TRAP(err, entry.InstallTypeL());
+	CheckFailL(err, _L("InstallTypeL"));
+
+	CleanupStack::PopAndDestroy(2, &session);
+	}
+
+CDaemonRegistryCapTest* CDaemonRegistryCapTest::NewL()
+	{
+	CDaemonRegistryCapTest* self=new(ELeave) CDaemonRegistryCapTest();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CDaemonRegistryCapTest::CDaemonRegistryCapTest()
+	{
+	SetSidRequired(Swi::KDaemonSecureId);
+	}
+	
+void CDaemonRegistryCapTest::ConstructL()
+	{
+	SetNameL(KDaemonRegistryCapTestName);
+	}
+
+void CDaemonRegistryCapTest::RunTestL()
+	{
+	Swi::RSisRegistryWritableSession session;
+	CleanupClosePushL(session);
+		
+	TInt err = session.Connect();
+	
+	if (KErrNone != err)
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+
+	const TInt KTestDrive=7; // random drive
+	TRAP(err, session.AddDriveL(KTestDrive));
+	CheckFailL(err, _L("AddDriveL"));
+
+#ifndef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+	TRAP(err, session.RemoveDriveL(KTestDrive));
+	CheckFailL(err, _L("RemoveDriveL"));
+#endif
+
+	TRAP(err, session.RecoverL());
+	CheckFailL(err, _L("RecoverL"));
+
+	CleanupStack::PopAndDestroy(&session);
+	}
+
+
+CRevocationRegistryCapTest* CRevocationRegistryCapTest::NewL()
+	{
+	CRevocationRegistryCapTest* self=new(ELeave) CRevocationRegistryCapTest();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CRevocationRegistryCapTest::CRevocationRegistryCapTest()
+	{
+	SetCapabilityRequired(ECapabilityNetworkServices);
+	SetCapabilityRequired(ECapabilityWriteUserData);
+	}
+	
+void CRevocationRegistryCapTest::ConstructL()
+	{
+	SetNameL(KRevocationRegistryCapTestName);
+	}
+
+void CRevocationRegistryCapTest::RunTestL()
+	{
+	Swi::RSisRegistryWritableSession session;
+	CleanupClosePushL(session);
+		
+	TInt err = session.Connect();
+	
+	if (KErrNone != err)
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+
+	Swi::RSisRevocationEntry entry;
+	
+	TUid uidOpen = {0x101f7989}; // Package known to exist
+	
+	if (KErrNone != entry.Open(session, uidOpen))
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+
+	CleanupClosePushL(entry);
+
+	TRAP(err, entry.CheckRevocationStatusL(_L8("dummy")));
+	CheckFailL(err, _L("CheckRevocationStatus"));
+
+	CleanupStack::PopAndDestroy(2,&session);
+	}
+
+
+#ifdef SYMBIAN_UNIVERSAL_INSTALL_FRAMEWORK
+
+CSifServerRegistryCapTest* CSifServerRegistryCapTest::NewL()
+	{
+	CSifServerRegistryCapTest* self=new(ELeave) CSifServerRegistryCapTest();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+CSifServerRegistryCapTest::CSifServerRegistryCapTest()
+	{
+	SetSidRequired(TUid::Uid(0x10285BCB)); //SIF servers's UID3 (ie: SID)
+	}
+	
+void CSifServerRegistryCapTest::ConstructL()
+	{
+	SetNameL(KSifServerRegistryCapTestName);
+	}
+
+void CSifServerRegistryCapTest::RunTestL()
+	{
+	Usif::TComponentId componentId(0x01);
+	Swi::RSisRegistryWritableSession session;
+	CleanupClosePushL(session);
+		
+	TInt err = session.Connect();
+	if (KErrNone != err)
+		{
+		SetFail();
+		CleanupStack::PopAndDestroy(&session);
+		return;
+		}
+
+	TRAP(err, session.ActivateComponentL(componentId));
+	CheckFailL(err, _L("ActivateComponentL"));
+
+	TRAP(err, session.DeactivateComponentL(componentId));
+	CheckFailL(err, _L("DeactivateComponentL"));
+
+	CleanupStack::PopAndDestroy(&session);
+	}
+#endif
+
+