--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/dbms/tdbms/t_dbplatsec.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,674 @@
+// 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;
+ }