// 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 "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:

// DBMS security policy - testing new APIs

// All tests assume that drive C is presented in the system and is not a ROM drive.

// Please, ensure that t_dbenvcreate test is executed before t_dbplatsec<N>/t_dbplatsecperf tests!

// Please, ensure that t_dbenvdestroy test is executed after t_dbplatsec<N>/t_dbplatsecperf tests!

// 

//

#include <d32dbms.h>

#include <e32test.h>

#include "t_dbplatsecdef.h"

#include "t_dbplatsecutl.h"

#include "t_dbplatsecdb.h"

#include "t_dbplatsectbl.h"

//Global definitions

RTest 				TheTest(_L("t_dbplatsec : DBMS platform security testing"));

RDbs 				TheDbs;

RDbNamedDatabase 	TheDb1;

RDbNamedDatabase 	TheDb2;

RDbTable			TheTbl1;

RDbTable			TheTbl2;

void 		DeleteDatabases();

TDBSCUtils 	TheDbscUtils(TheTest, &DeleteDatabases);

void DeleteDatabases()

	{

	TheTbl1.Close();

	TheTbl2.Close();

	TheDb2.Close();

	TheDb1.Close();

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb2Name);

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb3Name);

	}

static void GetDatabaseRPolicyTest()

	{

	TSecurityPolicy policy;

	TInt err = TheDbs.GetDatabasePolicy(KSecureDbUid, RDbs::EReadPolicy, policy);

	TEST2(err, KErrNone);

	TCompiledSecurityPolicy testSecurityPolicy(policy);

	TSecurityPolicy::TType type = testSecurityPolicy.Type();

	TEST(type == TSecurityPolicy::ETypeC3);

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityCommDD));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityPowerMgmt));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityTrustedUI));

	}

static void GetDatabaseWPolicyTest()

	{

	TSecurityPolicy policy;

	TInt err = TheDbs.GetDatabasePolicy(KSecureDbUid, RDbs::EWritePolicy, policy);

	TEST2(err, KErrNone);

	TCompiledSecurityPolicy testSecurityPolicy(policy);

	TSecurityPolicy::TType type = testSecurityPolicy.Type();

	TEST(type == TSecurityPolicy::ETypeC3);

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityMultimediaDD));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityReadDeviceData));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, static_cast <TCapability> (TUint8(ECapability_None))));

	}

static void GetDatabaseSPolicyTest()

	{

	TSecurityPolicy policy;

	TInt err = TheDbs.GetDatabasePolicy(KSecureDbUid, RDbs::ESchemaPolicy, policy);

	TEST2(err, KErrNone);

	TCompiledSecurityPolicy testSecurityPolicy(policy);

	TSecurityPolicy::TType type = testSecurityPolicy.Type();

	TEST(type == TSecurityPolicy::ETypeC7);

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityWriteDeviceData));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityDRM));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityProtServ));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityDiskAdmin));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityNetworkControl));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilityWriteUserData));

	TEST(TDBSCUtils::HasCapability(testSecurityPolicy, ECapabilitySwEvent));

	}

static void GetTablePolicyTest(const TDesC& aTableName,

							   RDbs::TPolicyType aPolicyType,

							   TSecurityPolicy::TType aType,

							   TSecureId aSecureId,

							   TVendorId aVendorId,

							   const TCapability* aCapabilities, TInt aCapCount)

	{

	TSecurityPolicy policy;

	TInt err = TheDbs.GetTablePolicy(KSecureDbUid, aTableName, aPolicyType, policy);

	TEST2(err, KErrNone);

	TCompiledSecurityPolicy testSecurityPolicy(policy);

	TEST(testSecurityPolicy.Type() == aType);

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

		{

		TEST(TDBSCUtils::HasCapability(testSecurityPolicy, aCapabilities[i]));

		}

	if(testSecurityPolicy.Type() == TSecurityPolicy::ETypeS3)

		{

		TEST(testSecurityPolicy.SecureId() == aSecureId);

		}

	else if(testSecurityPolicy.Type() == TSecurityPolicy::ETypeV3)

		{

		TEST(testSecurityPolicy.VendorId() == aVendorId);

		}

	}

//Tests RDbs::GetDatabasePolicy()/RDbs::GetTablePolicy() with invalid arguments

static void InvalidPolicyArgTestsL()

	{

	TheTest.Printf(_L("--Invalid UID\n"));

	const TUid KInvalidUid = {0x490122};

	TSecurityPolicy policy;

	TInt err = TheDbs.GetDatabasePolicy(KInvalidUid, RDbs::EWritePolicy, policy);

	TEST2(err, KErrArgument);

	err = TheDbs.GetDatabasePolicy(KNullUid, RDbs::EWritePolicy, policy);

	TEST2(err, KErrArgument);

	err = TheDbs.GetTablePolicy(KInvalidUid, KTableName1, RDbs::EWritePolicy, policy);

	TEST2(err, KErrArgument);

	err = TheDbs.GetTablePolicy(KNullUid, KTableName1, RDbs::EWritePolicy, policy);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Invalid policy type\n"));

	err = TheDbs.GetDatabasePolicy(KSecureDbUid, static_cast <RDbs::TPolicyType> (100), policy);

	TEST2(err, KErrArgument);

	err = TheDbs.GetTablePolicy(KSecureDbUid, KTableName2, static_cast <RDbs::TPolicyType> (101), policy);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Table name, which is not in the policy file\n"));

	_LIT(KMissingTableName, "AAAAAA");

	err = TheDbs.GetTablePolicy(KSecureDbUid, KMissingTableName, RDbs::EWritePolicy, policy);

	TEST2(err, KErrNone);//This must be the related database policy

	TSecurityPolicy dbPolicy;

	err = TheDbs.GetDatabasePolicy(KSecureDbUid, RDbs::EWritePolicy, dbPolicy);

	TEST2(err, KErrNone);

	TCompiledSecurityPolicy sp1(policy);

	TCompiledSecurityPolicy sp2(dbPolicy);

	TEST(sp1 == sp2);

	TheTest.Printf(_L("--Table name - zero length\n"));

	_LIT(KInvTableName, "");

	err = TheDbs.GetTablePolicy(KSecureDbUid, KInvTableName, RDbs::EWritePolicy, policy);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Table name - Schema policy request\n"));

	err = TheDbs.GetTablePolicy(KSecureDbUid, KTableName3, RDbs::ESchemaPolicy, policy);

	TEST2(err, KErrNotSupported);

	}

//Returns a valid drive number, but not presented in the system

static TDriveNumber FirstNotPresentedDriveNumber()

	{

	RFs fs;

	TEST2(fs.Connect(), KErrNone);

	TDriveNumber drvNumber = static_cast <TDriveNumber> (1000);

	for(TInt i=EDriveA;i<=EDriveZ;++i)

		{

		TDriveInfo driveInfo;

		if(fs.Drive(driveInfo, static_cast <TDriveNumber> (i)) == KErrNone)

			{

			if(driveInfo.iType == EMediaNotPresent)

				{

				drvNumber = static_cast <TDriveNumber> (i);

				break;

				}

			}

		}

	fs.Close();

	TEST(drvNumber <= EDriveZ);

	return drvNumber;

	}

//Returns the first valid ROM drive number.

static TDriveNumber FirstROMDriveNumber()

	{

	RFs fs;

	TEST2(fs.Connect(), KErrNone);

	TDriveNumber drvNumber = static_cast <TDriveNumber> (1000);

	for(TInt i=EDriveA;i<=EDriveZ;++i)

		{

		TDriveInfo driveInfo;

		if(fs.Drive(driveInfo, static_cast <TDriveNumber> (i)) == KErrNone)

			{

			if(driveInfo.iDriveAtt & KDriveAttRom)

				{

				drvNumber = static_cast <TDriveNumber> (i);

				break;

				}

			}

		}

	fs.Close();

	TEST(drvNumber <= EDriveZ);

	return drvNumber;

	}

//Tests RDbs::DatabaseNamesL() with invalid arguments

static void InvalidPolicyArgTests2L()

	{

	CDbDatabaseNames* dbNames = NULL;

	TheTest.Printf(_L("--Invalid UID\n"));

	const TUid KInvalidUid = {0x490122};

	TRAPD(err, dbNames = TheDbs.DatabaseNamesL(EDriveC, KInvalidUid));

	TEST2(err, KErrArgument);

	TEST(dbNames == NULL);

	TheTest.Printf(_L("--Null UID\n"));

	TRAP(err, dbNames = TheDbs.DatabaseNamesL(EDriveC, KNullUid));

	TEST2(err, KErrArgument);

	TEST(dbNames == NULL);

	TheTest.Printf(_L("--Invalid drive\n"));

	TRAP(err, dbNames = TheDbs.DatabaseNamesL(static_cast <TDriveNumber> (-1), KSecureDbUid));

	TEST2(err, KErrBadName);

	TEST(dbNames == NULL);

	TRAP(err, TheDbs.DatabaseNamesL(static_cast <TDriveNumber> (1765), KSecureDbUid));

	TEST2(err, KErrBadName);

	TEST(dbNames == NULL);

	TheTest.Printf(_L("--Valid drive number, but not presented in the system\n"));

	TDriveNumber driveNumber = ::FirstNotPresentedDriveNumber();

	TRAP(err, dbNames = TheDbs.DatabaseNamesL(driveNumber, KSecureDbUid));

	TEST2(err, KErrNotReady);

	TEST(dbNames == NULL);

	}

/**

@SYMTestCaseID SYSLIB-DBMS-CT-0003

@SYMTestCaseDesc Test RDbs::GetDatabasePolicy(), RDbs::GetTablePolicy()

                 getting database or table security policies.

@SYMTestPriority High

@SYMTestActions  A call with valid arguments and result check.

				 A call with an invalid UID.

				 A call with an invalid security policy type.

				 A call with a table name, not presented in the policy file.

				 A call requesting schema security policy of a table.

@SYMTestExpectedResults The test must not fail.

@SYMREQ          REQ2429

                 DBMS shall provide an API to apply security policies to database tables.

*/

static void GetPolicyTestL()

	{

	TheTest.Printf(_L("--Simple GetDatabasePolicy() tests\n"));

	::GetDatabaseRPolicyTest();

	::GetDatabaseWPolicyTest();

	::GetDatabaseSPolicyTest();

	::InvalidPolicyArgTestsL();

	TheTest.Printf(_L("--Simple GetTablePolicy() tests\n"));

	TCapability caps1[] = {ECapabilityCommDD, ECapabilityPowerMgmt, ECapabilityTrustedUI};

	TCapability caps2[] = {ECapabilityMultimediaDD, ECapabilityReadDeviceData};

	::GetTablePolicyTest(KTableName1, RDbs::EReadPolicy, TSecurityPolicy::ETypeC3, 0, 0, caps1, 3);

	::GetTablePolicyTest(KTableName1, RDbs::EWritePolicy, TSecurityPolicy::ETypeC3, 0, 0, caps2, 2);

	TCapability caps3[] = {static_cast <TCapability> (TUint8(ECapability_None))};

	::GetTablePolicyTest(KTableName2, RDbs::EReadPolicy, TSecurityPolicy::ETypeC3, 0, 0, caps3, 1);

	::GetTablePolicyTest(KTableName2, RDbs::EWritePolicy, TSecurityPolicy::ETypeC3, 0, 0, caps2, 2);

	TCapability caps4[] = {ECapabilityReadUserData};

	::GetTablePolicyTest(KTableName3, RDbs::EReadPolicy, TSecurityPolicy::ETypeC3, 0, 0, caps1, 3);

	::GetTablePolicyTest(KTableName3, RDbs::EWritePolicy, TSecurityPolicy::ETypeC3, 0, 0, caps4, 1);

	TCapability caps5[] = {ECapabilityWriteUserData};

	::GetTablePolicyTest(KTableName4, RDbs::EReadPolicy, TSecurityPolicy::ETypeC3, 0, 0, caps5, 1);

	::GetTablePolicyTest(KTableName4, RDbs::EWritePolicy, TSecurityPolicy::ETypeC3, 0, 0, caps2, 2);

	}

/**

@SYMTestCaseID SYSLIB-DBMS-CT-0004

@SYMTestCaseDesc Test RDbs::DatabaseNamesL(TDriveNumber, const TDesC&, TUid) -

                 getting a list of secure shared databases.

@SYMTestPriority High

@SYMTestActions  A call with valid arguments and result check

				 A call with an invalid drive number.

				 A call with a valid, but not presented in the system, drive number.

				 A call with an invalid UID.

@SYMTestExpectedResults The test must not fail.

@SYMREQ          REQ2429

                 DBMS shall provide an API to apply security policies to database tables.

*/

static void GetDatabaseListTestL()

	{

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb2Name);

	TheDb1 = TDBSCUtils::CreateDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TheDb1.Close();

	TheDb2 = TDBSCUtils::CreateDatabase(TheDbs, KSecureDbUid, KDb2Name);

	TheDb2.Close();

	TBuf<32> dbName;

	dbName.Copy(KDb1Name().Mid(KDatabaseNamePos));

	TEST(TDBSCUtils::IsDatabaseThereL(TheDbs, KSecureDbUid, EDriveC, dbName));

	dbName.Copy(KDb2Name().Mid(KDatabaseNamePos));

	TEST(TDBSCUtils::IsDatabaseThereL(TheDbs, KSecureDbUid, EDriveC, dbName));

	TheTest.Printf(_L("--An attempt to retrieve the list of database names for an UID, which security policy cannot be satisfied by the current test application\n"));

	CDbDatabaseNames* dbNames = NULL;

	TRAPD(err, dbNames = TheDbs.DatabaseNamesL(EDriveZ, KSecureDbUid2));

	delete dbNames;

	TEST2(err, KErrNone);

	::InvalidPolicyArgTests2L();

	}

/**

@SYMTestCaseID SYSLIB-DBMS-CT-0005

@SYMTestCaseDesc Test RDbs::CopyDatabase(const TDesC&, const TDesC&, TUid) -

                 copying secure shared database .

@SYMTestPriority High

@SYMTestActions  A call with valid arguments and result check

                 A call with an invalid source database name.

				 A call with an invalid target database name.

				 A call with an invalid UID.

				 An attempt to copy an opened database.

				 An attempt to copy a database, which security policy cannot be satisfied.

				 An attempt to copy a database with path specified in the database name.

				 An attempt to copy non-existing database.

@SYMTestExpectedResults The test must not fail.

@SYMREQ          REQ2429

                 DBMS shall provide an API to apply security policies to database tables.

*/

static void CopyDatabaseTestL()

	{

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TheDb1 = TDBSCUtils::CreateDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TheDb1.Close();

	TheTest.Printf(_L("--Simple copy test\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb3Name);

	TInt err = TheDbs.CopyDatabase(KDb1Name, KDb3Name, KSecureDbUid);

	TEST2(err, KErrNone);

	TBuf<32> dbName;

	dbName.Copy(KDb3Name().Mid(KDatabaseNamePos));

	TEST(TDBSCUtils::IsDatabaseThereL(TheDbs, KSecureDbUid, EDriveC, dbName));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb3Name);

	TheTest.Printf(_L("--An attempt to copy a source database, which security policy cannot be satisfied by the current test application\n"));

	err = TheDbs.CopyDatabase(KProtDb1ZName, KDb3Name, KSecureDbUid2);

	TEST2(err, KErrPermissionDenied);

	TheTest.Printf(_L("--Null source database name\n"));

	err = TheDbs.CopyDatabase(KNullDesC, KDb3Name, KSecureDbUid);

	TEST2(err, KErrArgument);

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb3Name);

	TheTest.Printf(_L("--Source database name with not presented drive number\n"));

	TDriveNumber driveNumber = ::FirstNotPresentedDriveNumber();

	TChar driveChar;

	TEST2(RFs::DriveToChar(driveNumber, driveChar), KErrNone);

	TBuf<KDatabaseNamePos> drvBuf;

	drvBuf.Append(driveChar);

	drvBuf.Append(':');

	dbName.Copy(drvBuf);

	dbName.Append(KDb1Name().Mid(KDatabaseNamePos));

	err = TheDbs.CopyDatabase(dbName, KDb3Name, KSecureDbUid);

	TEST2(err, KErrNotReady);

	TheTest.Printf(_L("--Source database name - only with a drive letter and \":\"\n"));

	err = TheDbs.CopyDatabase(drvBuf, KDb3Name, KSecureDbUid);

	TEST2(err, KErrNotReady);

	TheTest.Printf(_L("--Source database name - only with a drive letter\n"));

	drvBuf.SetLength(1);

	err = TheDbs.CopyDatabase(drvBuf, KDb3Name, KSecureDbUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Null destination database name\n"));

	err = TheDbs.CopyDatabase(KDb1Name, KNullDesC, KSecureDbUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Destination database name with not presented drive number\n"));

	drvBuf.Append(':');

	dbName.Copy(drvBuf);

	dbName.Append(KDb3Name().Mid(KDatabaseNamePos));

	err = TheDbs.CopyDatabase(KDb1Name, dbName, KSecureDbUid);

	TEST2(err, KErrNotReady);

	TheTest.Printf(_L("--Destination database - ROM drive\n"));

	TDriveNumber romDriveNumber = ::FirstROMDriveNumber();

	TEST2(RFs::DriveToChar(romDriveNumber, driveChar), KErrNone);

	drvBuf[0] = static_cast <TText> (driveChar);

	dbName.Copy(drvBuf);

	dbName.Append(KDb3Name().Mid(KDatabaseNamePos));

	err = TheDbs.CopyDatabase(KDb1Name, dbName, KSecureDbUid);

	TEST2(err, KErrAccessDenied);

	TheTest.Printf(_L("--A source database with a valid name, but not presented in the system\n"));

	_LIT(KMissingDb, "C:asdhasfsudfygusdfuierfb.db");

	err = TheDbs.CopyDatabase(KMissingDb, KDb3Name, KSecureDbUid);

	TEST2(err, KErrNotFound);

	TheTest.Printf(_L("--A test with an open source database\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TheDb2 = TDBSCUtils::CreateDatabase(TheDbs, KSecureDbUid, KDb1Name);

	err = TheDbs.CopyDatabase(KDb1Name, KDb3Name, KSecureDbUid);

	TheDb2.Close();

	TEST2(err, KErrInUse);

	TheTest.Printf(_L("--An atempt to copy over an existing database\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb2Name);

	TheDb1 = TDBSCUtils::CreateDatabase(TheDbs, KSecureDbUid, KDb2Name);

	TheDb1.Close();

	err = TheDbs.CopyDatabase(KDb1Name, KDb2Name, KSecureDbUid);

	TEST2(err, KErrAlreadyExists);

	TheTest.Printf(_L("--Too long destination database name > KDbMaxName symbols\n"));

	_LIT(KTooLongDbName, "A_0123456789_0123456789_0123456789_0123456789_0123456789_0123456789_0123456789.db");

	err = TheDbs.CopyDatabase(KDb1Name, KTooLongDbName, KSecureDbUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Null UID\n"));

	err = TheDbs.CopyDatabase(KDb1Name, KDb3Name, KNullUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Invalid UID\n"));

	const TUid KInvalidUid = {0x490122};

	err = TheDbs.CopyDatabase(KDb1Name, KDb3Name, KInvalidUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--An attempt to copy a database with the path specified in the name\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb2Name);

	_LIT(KSrcDbName2, "C:\\a.Db");

	_LIT(KDestDbName2, "C:\\b.dB");

	err = TheDbs.CopyDatabase(KSrcDbName2, KDestDbName2, KSecureDbUid);

	TEST2(err, KErrArgument);

	}

/**

@SYMTestCaseID SYSLIB-DBMS-CT-0006

@SYMTestCaseDesc Test RDbs::Delete(const TDesC&, TUid) - deleting secure shared database .

@SYMTestPriority High

@SYMTestActions  A call with valid arguments and result check

                 A call with an invalid UID.

				 A call with an invalid database name.

				 An attempt to delete an opened database.

				 An attempt to delete a database, which security policy cannot be satisfied.

				 An attempt to delete a database with path specified in the database name.

				 An attempt to delete non-existing database.

@SYMTestExpectedResults The test must not fail.

@SYMREQ          REQ2429

                 DBMS shall provide an API to apply security policies to database tables.

*/

static void DeleteDatabaseTestL()

	{

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TheDb1 = TDBSCUtils::CreateDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TheDb1.Close();

	TheTest.Printf(_L("--Simple delete database test\n"));

	TInt err = TheDbs.DeleteDatabase(KDb1Name, KSecureDbUid);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("--Null UID\n"));

	err = TheDbs.DeleteDatabase(KDb1Name, KNullUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Invalid UID\n"));

	const TUid KInvalidUid = {0x490122};

	err = TheDbs.DeleteDatabase(KDb1Name, KInvalidUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Null database name\n"));

	err = TheDbs.DeleteDatabase(KNullDesC, KSecureDbUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Non-existing database - no drive letter (the name is invalid)\n"));

	_LIT(KTooLongDbName, "A_0123456789_0123456789_0123456789_0123456789_0123456789_0123456789_0123456789.db");

	err = TheDbs.DeleteDatabase(KTooLongDbName, KSecureDbUid);

	TEST2(err, KErrArgument);

	_LIT(KInvDbName1, "UI789.db");

	err = TheDbs.DeleteDatabase(KInvDbName1, KSecureDbUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Non-existing database - valid db name\n"));

	_LIT(KMissingDbName1, "C:A0192345.db");

	err = TheDbs.DeleteDatabase(KMissingDbName1, KSecureDbUid);

	TEST2(err, KErrNotFound);

	TheTest.Printf(_L("--An attempt to delete a database with the path specified in the name\n"));

	_LIT(KMissingDbName2, "C:\\TEMP\\A0192345.db");

	err = TheDbs.DeleteDatabase(KMissingDbName2, KSecureDbUid);

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--An attempt to delete a database, which security policy cannot be satisfied by the current test application\n"));

	err = TheDbs.DeleteDatabase(KProtDb1CName, KSecureDbUid2);

	TEST2(err, KErrPermissionDenied);

	TheTest.Printf(_L("--An attempt to delete an open database\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TheDb1 = TDBSCUtils::CreateDatabase(TheDbs, KSecureDbUid, KDb1Name);

	err = TheDbs.DeleteDatabase(KDb1Name, KSecureDbUid);

	TEST2(err, KErrInUse);

	TheDb1.Close();

	}

/**

@SYMTestCaseID SYSLIB-DBMS-CT-0007

@SYMTestCaseDesc Test RDbNamedDatabase::Create(RDbs&, const TDesC&, const TDesC&) -

                 secure shared database creation.

@SYMTestPriority High

@SYMTestActions  A call with valid arguments and result check

                 An attempt to create already existing database.

				 An attempt to create already existing and opened database.

				 RDbNamedDatabase::Create() called with an invalid format string.

				 RDbNamedDatabase::Create() called with a database name containing '\' symbols.

				 An attempt to create a database, which security policy cannot be satisfied.

@SYMTestExpectedResults The test must not fail.

@SYMREQ          REQ2429

                 DBMS shall provide an API to apply security policies to database tables.

*/

static void CreateDatabaseL()

	{

	TheTest.Printf(_L("--Simple create database test\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	TBuf<32> format;

	format.Copy(KSecure);

	format.Append(KSecureDbUid.Name());

	TInt err = TheDb1.Create(TheDbs, KDb1Name, format);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("--An atempt to recreate an open database\n"));

	err = TheDb1.Create(TheDbs, KDb1Name, format);

	TEST2(err, KErrAlreadyExists);

	TheDb1.Close();

	TheTest.Printf(_L("--An atempt to recreate an existing database\n"));

	err = TheDb1.Create(TheDbs, KDb1Name, format);

	TEST2(err, KErrAlreadyExists);

	TheTest.Printf(_L("--Format string with \"SECURE\" keyword and some other words too\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	format.Copy(_L("A "));

	format.Append(KSecure);

	format.Append(_L(" B"));

	format.Append(KSecureDbUid.Name());

	err = TheDb1.Create(TheDbs, KDb1Name, format);

	TheDb1.Close();

	TEST2(err, KErrNotSupported);

	TheTest.Printf(_L("--Format string with \"SeCuRe\" keyword\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	format.Copy(_L("SeCuRe"));

	format.Append(KSecureDbUid.Name());

	err = TheDb1.Create(TheDbs, KDb1Name, format);

	TheDb1.Close();

	TEST2(err, KErrNone);

	TheTest.Printf(_L("--Format string with \"SECURED\" keyword\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	format.Copy(_L("SECURED"));

	format.Append(KSecureDbUid.Name());

	err = TheDb1.Create(TheDbs, KDb1Name, format);

	TheDb1.Close();

	TEST2(err, KErrNotSupported);

	TheTest.Printf(_L("--Format string with a null uid\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	format.Copy(_L("SECURE"));

	format.Append(KNullUid.Name());

	err = TheDb1.Create(TheDbs, KDb1Name, format);

	TheDb1.Close();

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Format string with an invalid uid\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	format.Copy(_L("SECURE"));

	const TUid KInvalidUid = {0x490122};

	format.Append(KInvalidUid.Name());

	err = TheDb1.Create(TheDbs, KDb1Name, format);

	TheDb1.Close();

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--Format string with a uid only\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	format.Copy(KSecureDbUid.Name());

	err = TheDb1.Create(TheDbs, KDb1Name, format);

	TheDb1.Close();

	TEST2(err, KErrNotSupported);

	TheTest.Printf(_L("--Blank format string\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	format.Zero();

	err = TheDb1.Create(TheDbs, KDb1Name, format);

	TheDb1.Close();

	TEST2(err, KErrNotSupported);

	TheTest.Printf(_L("--Valid format string + database name with a path\n"));

	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);

	format.Copy(KSecure);

	format.Append(KSecureDbUid.Name());

	_LIT(KSrcDbName2, "C:\\a.Db");

	err = TheDb1.Create(TheDbs, KSrcDbName2, format);

	TheDb1.Close();

	TEST2(err, KErrArgument);

	TheTest.Printf(_L("--An attempt to create a database, which security policy cannot be satisfied by the current test application\n"));

	format.Copy(KSecure);

	format.Append(KSecureDbUid2.Name());

	err = TheDb1.Create(TheDbs, KProtDb2CName, format);

	TheDb1.Close();

	TEST2(err, KErrPermissionDenied);

	}

static void INC057327L()

    {

     TRAPD(err,delete TheDbs.DatabaseNamesL(EDriveZ, TUid::Uid(0x12344321)));

     TheTest(err == KErrNone);

    }

static void DoRunL()

	{

	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0003 Get database/table policies "));

	::GetPolicyTestL();

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0004 Get databases list "));

	::GetDatabaseListTestL();

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0005 Copy database "));

	::CopyDatabaseTestL();

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0006 Delete database "));

	::DeleteDatabaseTestL();

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0007 Create database "));

	::CreateDatabaseL();

	TheTest.Next(_L("Database security"));

	::DoDbTestL();

	TheTest.Next(_L("Table security"));

	::DoTblTestL();

	TheTest.Next(_L("Test for INC057327"));

	::INC057327L();

	}

TInt E32Main()

    {

	__UHEAP_MARK;

	CTrapCleanup* tc = CTrapCleanup::New();

	TEST(tc != NULL);

	TInt err = TheDbs.Connect();

	TEST2(err, KErrNone);

	TRAP(err, ::DoRunL());

	TEST2(err, KErrNone);

	::DeleteDatabases();

	TheDbs.Close();

	TheTest.End();

	TheTest.Close();

	delete tc;

	__UHEAP_MARKEND;

	User::Heap().Check();

	return KErrNone;

    }