// 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 - performance tests
// 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 <e32test.h>
#include "t_dbplatsecutl.h"
static RTest TheTest(_L("t_dbplatsecperf: DBMS platform security - Performance test"));
static RDbs TheDbs;
static RDbNamedDatabase TheDb;
const TUid KSecureDbUid = {0x11335579};
_LIT(KSecure, "SECURE");
_LIT(KDbNameC, "C:TestDB.DB");
_LIT(KTblNameA, "A");
_LIT(KTblNameB, "B");
_LIT(KTblNameC, "C");
_LIT(KDbDirNSC, "C:\\DBMS-TST\\");
_LIT(KDbNameNSC,"C:\\DBMS-TST\\TestDB.DB");
static void DeleteNsDb()
{
RFs fileSess;
if(fileSess.Connect() == KErrNone)
{
fileSess.Delete(KDbNameNSC);
}
fileSess.Close();
}
static void CleanupTest()
{
::DeleteNsDb();
}
TDBSCUtils TheDbscUtils(TheTest, &CleanupTest);
const TInt KGetPolicyCallCnt = 10000;
const TInt KInsertRecCnt = 10000;
//Measures the performance of RDbs::GetDatabasePolicy() and RDbs::GetTablePolicy() calls.
//The DBMS server session kept alive during the test.
static void GetPolicyTest1()
{
TUint time = User::TickCount();
RDbs::TPolicyType tblPolicyType[2] = {RDbs::EReadPolicy, RDbs::EWritePolicy};
TSecurityPolicy dbPolicy;
TSecurityPolicy tblPolicy;
TInt i, k;
for(i=0,k=0;i<KGetPolicyCallCnt;++i,k=(k+1)%2)
{
TInt err = TheDbs.GetDatabasePolicy(KSecureDbUid, tblPolicyType[k], dbPolicy);
TEST2(err, KErrNone);
err = TheDbs.GetTablePolicy(KSecureDbUid, KTblNameA, tblPolicyType[k], tblPolicy);
TEST2(err, KErrNone);
}
time = User::TickCount() - time;
TheTest.Printf(_L("GetDatabasePolicy(), GetTablePolicy(). Time=%d\r\n"), time);
}
//Measures the performance of RDbs::GetTablePolicies() call.
//The DBMS server session connected before each GetTablePolicies() call and disconnected
//after the call.
static void GetPolicyTest2()
{
TheDbs.Close();
TUint time = User::TickCount();
RDbs::TPolicyType tblPolicyType[2] = {RDbs::EReadPolicy, RDbs::EWritePolicy};
TSecurityPolicy dbPolicy;
TSecurityPolicy tblPolicy;
TInt i, k;
for(i=0,k=0;i<KGetPolicyCallCnt;++i,k=(k+1)%2)
{
TInt err = TheDbs.Connect();
TEST2(err, KErrNone);
err = TheDbs.GetTablePolicies(KSecureDbUid, KTblNameA, tblPolicyType[k], dbPolicy, tblPolicy);
TEST2(err, KErrNone);
TheDbs.Close();
}
time = User::TickCount() - time;
TheTest.Printf(_L("GetTablePolicies(). Time=%d\r\n"), time);
TInt err = TheDbs.Connect();
TEST2(err, KErrNone);
}
//Measures the performance of RDbs::GetTablePolicies() call.
//The DBMS server session kept alive during the test.
static void GetPolicyTest3()
{
TUint time = User::TickCount();
RDbs::TPolicyType tblPolicyType[2] = {RDbs::EReadPolicy, RDbs::EWritePolicy};
TSecurityPolicy dbPolicy;
TSecurityPolicy tblPolicy;
TInt i, k;
for(i=0,k=0;i<KGetPolicyCallCnt;++i,k=(k+1)%2)
{
TInt err = TheDbs.GetTablePolicies(KSecureDbUid, KTblNameA, tblPolicyType[k], dbPolicy, tblPolicy);
TEST2(err, KErrNone);
}
time = User::TickCount() - time;
TheTest.Printf(_L("GetTablePolicies(). Time=%d\r\n"), time);
}
static void CreateNonsecureDbL()
{
TColDef const KColumns[]=
{
{_S("ID"), EDbColInt32, TDbCol::ENotNull | TDbCol::EAutoIncrement},
{_S("DATA1"), EDbColInt32, TDbCol::ENotNull},
{_S("DATA2"), EDbColInt32, TDbCol::ENotNull},
{0}
};
RFs fileSess;
CleanupClosePushL(fileSess);
TInt err = fileSess.Connect();
TEST2(err, KErrNone);
err = fileSess.MkDir(KDbDirNSC);
TEST(err == KErrNone || err == KErrAlreadyExists);
RDbNamedDatabase db;
err = db.Create(fileSess, KDbNameNSC);
TEST2(err, KErrNone);
CleanupClosePushL(db);
err = db.Open(fileSess, KDbNameNSC);
CDbColSet* colset = TDBSCUtils::CreateColSetLC(KColumns);
err = db.CreateTable(KTblNameA, *colset);
TEST2(err, KErrNone);
err = db.CreateTable(KTblNameB, *colset);
TEST2(err, KErrNone);
err = db.CreateTable(KTblNameC, *colset);
TEST2(err, KErrNone);
CleanupStack::PopAndDestroy(colset);
CleanupStack::PopAndDestroy(&db);
CleanupStack::PopAndDestroy(&fileSess);
}
static void DoInsertRecL(RDbNamedDatabase& aDb, RDbTable& aTbl)
{
TUint time = User::TickCount();
TInt err = aDb.Begin();
TEST2(err, KErrNone);
for(TInt i=0;i<KInsertRecCnt;++i)
{
aTbl.InsertL();
aTbl.SetColL(2, i);
aTbl.SetColL(3, i);
aTbl.PutL();
}
err = aDb.Commit();
TEST2(err, KErrNone);
time = User::TickCount() - time;
TheTest.Printf(_L("Insert. Time=%d\r\n"), time);
}
//Measures the performance of "Insert" operations in a non-secure database.
static void InsertRec1L()
{
RDbNamedDatabase db;
CleanupClosePushL(db);
TInt err = db.Open(TheDbs, KDbNameNSC);
TEST2(err, KErrNone);
RDbTable tblA;
CleanupClosePushL(tblA);
err = tblA.Open(db, KTblNameA);
TEST2(err, KErrNone);
::DoInsertRecL(db, tblA);
CleanupStack::PopAndDestroy(&tblA);
CleanupStack::PopAndDestroy(&db);
}
//Measures the performance of "Insert" operations in a secure shared database.
static void InsertRec2L()
{
TBuf<32> format;
format.Copy(KSecure);
format.Append(KSecureDbUid.Name());
CleanupClosePushL(TheDb);
TInt err = TheDb.Open(TheDbs, KDbNameC, format);
TEST2(err, KErrNone);
RDbTable tblA;
CleanupClosePushL(tblA);
err = tblA.Open(TheDb, KTblNameA);
TEST2(err, KErrNone);
::DoInsertRecL(TheDb, tblA);
CleanupStack::PopAndDestroy(&tblA);
CleanupStack::PopAndDestroy(&TheDb);
}
//Measures the performance of "Update" SQL operations in a non-secure database.
static void UpdateRec1L()
{
RDbNamedDatabase db;
CleanupClosePushL(db);
TInt err = db.Open(TheDbs, KDbNameNSC);
TEST2(err, KErrNone);
TUint time = User::TickCount();
err = db.Begin();
TEST2(err, KErrNone);
TInt cnt = db.Execute(_L("UPDATE A SET DATA1=10, DATA2=20 WHERE ID >= 0"));
TEST(cnt > 0);
err = db.Commit();
TEST2(err, KErrNone);
time = User::TickCount() - time;
TheTest.Printf(_L("Update. Time=%d\r\n"), time);
CleanupStack::PopAndDestroy(&db);
}
//Measures the performance of "Update" SQL operations in a secure shared database.
static void UpdateRec2L()
{
TBuf<32> format;
format.Copy(KSecure);
format.Append(KSecureDbUid.Name());
CleanupClosePushL(TheDb);
TInt err = TheDb.Open(TheDbs, KDbNameC, format);
TEST2(err, KErrNone);
TUint time = User::TickCount();
err = TheDb.Begin();
TEST2(err, KErrNone);
TInt cnt = TheDb.Execute(_L("UPDATE A SET DATA1=10, DATA2=20 WHERE ID >= 0"));
TEST(cnt > 0);
err = TheDb.Commit();
TEST2(err, KErrNone);
time = User::TickCount() - time;
TheTest.Printf(_L("Update. Time=%d\r\n"), time);
CleanupStack::PopAndDestroy(&TheDb);
}
/**
@SYMTestCaseID SYSLIB-DBMS-CT-0020
@SYMTestCaseDesc DBMS security - performance tests. Insert/Update and Get<AAA>Policy
operations performance measured for non-secure and secure shared database.
@SYMTestPriority High
@SYMTestActions RDbs::GetDatabasePolicy(), Rdbs::GetTablePolicy() and RDbs::GetTablePolicies()
calls measured.
RDBTable: insert operation measured, SQL: update operation measured.
@SYMTestExpectedResults The test must not fail.
@SYMREQ REQ2429
DBMS shall provide an API to apply security policies to database tables.
*/
static void DoRunL()
{
TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0020 GetPolicy performance test "));
::GetPolicyTest1();
::GetPolicyTest2();
::GetPolicyTest3();
::CreateNonsecureDbL();
TheTest.Next(_L("Insert records performance test"));
InsertRec1L();
InsertRec2L();
TheTest.Next(_L("Update records performance test"));
::UpdateRec1L();
::UpdateRec2L();
}
TInt E32Main()
{
__UHEAP_MARK;
CTrapCleanup* tc = CTrapCleanup::New();
TEST(tc != NULL);
TInt err = TheDbs.Connect();
TEST2(err, KErrNone);
::DeleteNsDb();
TRAP(err, ::DoRunL());
TEST2(err, KErrNone);
TheDb.Close();
TheDbs.Close();
::CleanupTest();
TheTest.End();
TheTest.Close();
delete tc;
__UHEAP_MARKEND;
User::Heap().Check();
return KErrNone;
}