// 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 - database level.

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

// 

//

#include "t_dbplatsecutl.h"

#include "t_dbplatsecdef.h"

#include "t_dbplatsecdb.h"

static TColDef const KColumns[]=

	{

	{_S("ID"), EDbColInt32, TDbCol::ENotNull | TDbCol::EAutoIncrement},

	{_S("DATA1"), EDbColInt32, TDbCol::ENotNull},

	{_S("DATA2"), EDbColInt32, TDbCol::ENotNull},

	{0}

	};

//Open database tests

static void OpenTestL()

	{

	RFs fileSess;

	CleanupClosePushL(fileSess);

	TEST2(fileSess.Connect(), KErrNone);

	TBuf<32> fmt;

	fmt.Copy(KSecure);

	fmt.Append(KSecureDbUid.Name());

	TheTest.Printf(_L("Open secure shared database\n"));

	TInt err = TheDb1.Open(TheDbs, KDb1Name, fmt);

	TheDb1.Close();

	TEST2(err, KErrNone);

	TheTest.Printf(_L("An attempt to open it as a secure shared database - no format string\n"));

	err = TheDb1.Open(TheDbs, KDb1Name);

	TheDb1.Close();

	TEST2(err, KErrNotFound);//Treated as a non-secure, not found database.

	TheTest.Printf(_L("An attempt to open it as a non-secure shared database\n"));

	_LIT(KNSDbName, "C:\\PRiVatE\\100012A5\\A.dB");

	err = TheDb1.Open(TheDbs, KNSDbName);

	TheDb1.Close();

	TEST2(err, KErrPermissionDenied);

    _LIT(KNSDbName2, "C:\\PRiVatE\\100012A5\\DBS_11335577_A.Db");

    if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement) && 

       PlatSec::IsCapabilityEnforced(ECapabilityAllFiles))

        {

	    err = TheDb1.Open(fileSess, KNSDbName2);

	    TheDb1.Close();

	    TEST2(err, KErrPermissionDenied);

		TheTest.Printf(_L("An attempt to create it as a non-secure shared database\n"));

		err = TheDb1.Create(fileSess, KNSDbName2);

		TheDb1.Close();

		TEST2(err, KErrPermissionDenied);

        }

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

	fmt.Copy(KSecure);

	fmt.Append(KSecureDbUid2.Name());

	err = TheDb1.Open(TheDbs, KProtDb3CName, fmt);

	TheDb1.Close();

	TEST2(err, KErrPermissionDenied);

	CleanupStack::PopAndDestroy(&fileSess);

	}

//RDbDatabase method calls test. All calls have to pass with KErrNone,

//because the test application has enough rights to do any R/W/S database operation.

static void DbCallTestL()

	{

	TBuf<32> fmt;

	fmt.Copy(KSecure);

	fmt.Append(KSecureDbUid.Name());

	TheTest.Printf(_L("Open()\n"));

	TInt err = TheDb1.Open(TheDbs, KDb1Name, fmt);

	TheTest.Printf(_L("IsDamaged()\n"));

	TBool res = TheDb1.IsDamaged();

	TEST(!res);

	TheTest.Printf(_L("Recover()\n"));

	err = TheDb1.Recover();

	TEST2(err, KErrNone);

	TheTest.Printf(_L("UpdateStats()\n"));

	err = TheDb1.UpdateStats();

	TEST2(err, KErrNone);

	TheTest.Printf(_L("Size()\n"));

	RDbDatabase::TSize size = TheDb1.Size();

	TheTest.Printf(_L("Compact()\n"));

	err = TheDb1.Compact();

	TEST2(err, KErrNone);

	TheTest.Printf(_L("Begin()/Commit()\n"));

	err = TheDb1.Begin();

	TEST2(err, KErrNone);

	res = TheDb1.InTransaction();

	TEST(res);

	err = TheDb1.Commit();

	TEST2(err, KErrNone);

	TheTest.Printf(_L("Begin()/Rollback()\n"));

	err = TheDb1.Begin();

	TEST2(err, KErrNone);

	res = TheDb1.InTransaction();

	TEST(res);

	TheDb1.Rollback();

	TheTest.Printf(_L("CreateTable()\n"));

	CDbColSet* colset = TDBSCUtils::CreateColSetLC(KColumns);

	_LIT(KTblName1, "A1");

	err = TheDb1.CreateTable(KTblName1, *colset);

	TEST2(err, KErrNone);

	_LIT(KTblName2, "A2");

	err = TheDb1.CreateTable(KTblName2, *colset);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("DropTable()\n"));

	err = TheDb1.DropTable(KTblName2);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("AlterTable()\n"));

	err = TheDb1.AlterTable(KTblName1, *colset);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("CreateIndex()\n"));

	CDbKey* key = TDBSCUtils::CreateKeyLC(KCol2);

	err = TheDb1.CreateIndex(KCol2, KTblName1, *key);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("DropIndex()\n"));

	err = TheDb1.DropIndex(KCol2, KTblName1);

	TEST2(err, KErrNone);

	TheTest.Printf(_L("TableNamesL()\n"));

	_LIT(KTblName3, "DdD");

	_LIT(KTblName4, "FFf");

	_LIT(KTblName5, "Ggg");

	TDBSCUtils::CreateTableL(TheDb1, KTblName3, KColumns);

	TDBSCUtils::CreateTableL(TheDb1, KTblName4, KColumns);

	TDBSCUtils::CreateTableL(TheDb1, KTblName5, KColumns);

	CDbTableNames* tblNames = TheDb1.TableNamesL();

	TInt cnt = tblNames->Count();

	TEST(cnt == 4);

	TInt i;

	for(i=0;i<cnt;++i)

		{

		const TDesC& name = (*tblNames)[i];

		TheTest.Printf(_L("%02d, %S\n"), i + 1, &name);

		}

	delete tblNames;

	TheTest.Printf(_L("ColSetL()\n"));

	CDbColSet* cs1 = TheDb1.ColSetL(KTblName3);

	cnt = cs1->Count();

	for(i=0;i<cnt;++i)

		{

		const TDbCol& dbc = (*cs1)[i + 1];

		TheTest.Printf(_L("%02d, %S\n"), i + 1, &dbc.iName);

		}

	delete cs1;

	TheTest.Printf(_L("IndexNamesL()\n"));

	CDbKey* tblKey1 = TDBSCUtils::CreateKeyLC(KCol2);

	err = TheDb1.CreateIndex(KCol2, KTblName1, *tblKey1);

	TEST2(err, KErrNone);

	CleanupStack::PopAndDestroy(tblKey1);

	CDbIndexNames* dbiNames = TheDb1.IndexNamesL(KTblName1);

	cnt = dbiNames->Count();

	for(i=0;i<cnt;++i)

		{

		const TDesC& name = (*dbiNames)[i];

		TheTest.Printf(_L("%02d, %S\n"), i + 1, &name);

		}

	delete dbiNames;

	TheTest.Printf(_L("KeyL()\n"));

	CDbKey* tblKey2 = TheDb1.KeyL(KCol2, KTblName1);

	delete tblKey2;

	CleanupStack::PopAndDestroy(key);

	CleanupStack::PopAndDestroy(colset);

	TheDb1.Close();

	}

static void SQLTestL()

	{

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

	TheDb1.Close();

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

	TheTest.Printf(_L("Create table\n"));

	TInt err = TheDb1.Execute(_L("crEAte tabLe a (id couNter)"));

	TEST2(err, KErrNone);

	TheTest.Printf(_L("Alter table\n"));

	err = TheDb1.Execute(_L("ALter TablE a aDd DaTA1 CHaR(20)"));

	TEST2(err, KErrNone);

	err = TheDb1.Execute(_L("alter table A add DATA2 INTEGER"));

	TEST2(err, KErrNone);

	err = TheDb1.Execute(_L("ALTEr tABLe A dROp DaTa1"));

	TEST2(err, KErrNone);

	TheTest.Printf(_L("Drop table\n"));

	err = TheDb1.Execute(_L("DRop tABle a"));

	TEST2(err, KErrNone);

	err = TheDb1.Execute(_L("crEAte tabLe a (iD coUNteR)"));

	TEST2(err, KErrNone);

	err = TheDb1.Execute(_L("altER taBLe A add daTA2 InteGER"));

	TEST2(err, KErrNone);

	err = TheDb1.Execute(_L("creaTE tAblE b (Id counTEr)"));

	TEST2(err, KErrNone);

	err = TheDb1.Execute(_L("alter TAbLe B aDd DAtA2 INTEgER"));

	TEST2(err, KErrNone);

	TheTest.Printf(_L("Create index\n"));

	err = TheDb1.Execute(_L("CREAte INdeX idX oN A(dATA2)"));

	TEST2(err, KErrNone);

	TheTest.Printf(_L("Drop index\n"));

	err = TheDb1.Execute(_L("DroP IndEX idx frOm a"));

	TEST2(err, KErrNone);

	TheTest.Printf(_L("Insert\n"));

	TInt cnt = TheDb1.Execute(_L("INSerT IntO A (DATa2) VALuES(45)"));

	TEST(cnt > 0);

	TheTest.Printf(_L("Update\n"));

	cnt = TheDb1.Execute(_L("UPDATe A SeT DAtA2=56 WheRE iD = 0"));

	TEST(cnt > 0);

	TheTest.Printf(_L("Delete\n"));

	cnt = TheDb1.Execute(_L("INSErt INtO B (DATA2) VALUES(100)"));

	TEST(cnt > 0);

	cnt = TheDb1.Execute(_L("INSERT INTo b (DATA2) VALUES(200)"));

	TEST(cnt > 0);

	cnt = TheDb1.Execute(_L("delete FROM B where ID = 1"));

	TEST(cnt > 0);

	TheDb1.Close();

	}

static void TwoDatabasesTestL()

    {

	TBuf<32> fmt;

	fmt.Copy(KSecure);

	fmt.Append(KSecureDbUid.Name());

    RDbNamedDatabase db1;

	TheTest.Printf(_L("Open secure shared database-1\n"));

	TInt err = db1.Open(TheDbs, KDb1Name, fmt);

	TEST2(err, KErrNone);

    RDbNamedDatabase db2;

	TheTest.Printf(_L("Open secure shared database-2\n"));

	err = db2.Open(TheDbs, KDb1Name, fmt);

	TEST2(err, KErrNone);

    db2.Close();

    db1.Close();

    }

/**

@SYMTestCaseID SYSLIB-DBMS-CT-0019

@SYMTestCaseDesc RDbNamedDatabase method calls test for a secure shared database.

                 Every method of RDbNamedDatabase class and its base class too, is called

				 and the result - asserted.

@SYMTestPriority High

@SYMTestActions  RDbNamedDatabase method calls test.

@SYMTestExpectedResults The test must not fail.

@SYMREQ          REQ2429

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

*/

void DoDbTestL()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-DBMS-CT-0019 "));	

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

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

	TheDb1.Close();

	TheTest.Next(_L("Open secure database test"));	

	::OpenTestL();

	TheTest.Next(_L("Secure Database calls test"));	

	::DbCallTestL();

	TheTest.Next(_L("SQL test"));	

	::SQLTestL();

	TheTest.Next(_L("Two databases test"));	

	::TwoDatabasesTestL();

	}