// 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 - table 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_dbplatsectbl.h"

static TColDef const KColumns[]=
	{
	{_S("ID"), EDbColInt32, TDbCol::ENotNull | TDbCol::EAutoIncrement},
	{_S("DATA1"), EDbColInt32, TDbCol::ENotNull},
	{_S("DATA2"), EDbColInt32, TDbCol::ENotNull},
	{0}
	};

static TColDef const KColumns2[]=
	{
	{_S("ID"), EDbColInt32, TDbCol::ENotNull | TDbCol::EAutoIncrement},
	{_S("DATA1"), EDbColLongBinary},
	{0}
	};

static void TblCallTestL()
	{
	TheTest.Next(_L("Open()"));	
	TInt err = TheTbl1.Open(TheDb1, KTableName1);
	TEST2(err, KErrNone);
	
	TheTest.Next(_L("ColSetL()"));	
	CDbColSet* colset = TheTbl1.ColSetL();
	TInt cnt = colset->Count();
	TInt i;
	for(i=0;i<cnt;++i)
		{
		const TDbCol& dbc = (*colset)[i + 1];
		TheTest.Printf(_L("%02d, %S\n"), i + 1, &dbc.iName);
		}
	delete colset;
	
	TheTest.Next(_L("ColDef()"));	
	TDbCol dbcol = TheTbl1.ColDef(1);
	TheTest.Printf(_L("%S\n"), &dbcol.iName);

	TheTest.Next(_L("InsertL()/SetColL()/PutL()"));	
	TheTbl1.InsertL();
	TheTbl1.SetColL(2, 1);
	TheTbl1.SetColL(3, 2);
	TheTbl1.PutL();
	TheTbl1.InsertL();
	TheTbl1.SetColL(2, 3);
	TheTbl1.SetColL(3, 4);
	TheTbl1.PutL();
	
	TheTest.Next(_L("AtRow()/AtBeginning()/AtEnd()"));	
	(void)TheTbl1.AtRow();
	(void)TheTbl1.AtBeginning();
	(void)TheTbl1.AtEnd();

	TheTest.Next(_L("BeginningL()/EndL()"));	
	TheTbl1.BeginningL();
	TheTbl1.EndL();

	TheTest.Next(_L("FirstL()/LastL()/PreviousL()/PreviousL()"));	
	TBool res = TheTbl1.FirstL();
	TEST(res);
	TheTbl1.GetL();
	TInt32 val1 = TheTbl1.ColInt32(1);
	TInt32 val2 = TheTbl1.ColInt32(2);
	TInt32 val3 = TheTbl1.ColInt32(3);
	TEST(val1 == 0);
	TEST(val2 == 1);
	TEST(val3 == 2);
	
	res = TheTbl1.LastL();
	TEST(res);
	TheTbl1.GetL();
	val1 = TheTbl1.ColInt32(1);
	val2 = TheTbl1.ColInt32(2);
	val3 = TheTbl1.ColInt32(3);
	TEST(val1 == 1);
	TEST(val2 == 3);
	TEST(val3 == 4);

	res = TheTbl1.PreviousL();
	TEST(res);
	TheTbl1.GetL();
	val1 = TheTbl1.ColInt32(1);
	val2 = TheTbl1.ColInt32(2);
	val3 = TheTbl1.ColInt32(3);
	TEST(val1 == 0);
	TEST(val2 == 1);
	TEST(val3 == 2);
	
	res = TheTbl1.NextL();
	TEST(res);
	TheTbl1.GetL();
	val1 = TheTbl1.ColInt32(1);
	val2 = TheTbl1.ColInt32(2);
	val3 = TheTbl1.ColInt32(3);
	TEST(val1 == 1);
	TEST(val2 == 3);
	TEST(val3 == 4);

	TheTest.Next(_L("UpdateL()"));	
	TheTbl1.UpdateL();
	TheTbl1.SetColL(2, 33);
	TheTbl1.SetColL(3, 44);
	TheTbl1.PutL();

	TheTest.Next(_L("Cancel()"));	
	TheTbl1.UpdateL();
	TheTbl1.SetColL(2, 36);
	TheTbl1.SetColL(3, 47);
	TheTbl1.Cancel();

	TheTest.Next(_L("DeleteL()"));	
	TheTbl1.DeleteL();

	TheTest.Next(_L("IsColNull()"));	
	CDbColSet* colset2 = TDBSCUtils::CreateColSetLC(KColumns2);
	_LIT(KTempTblName, "TempTbl");
	err = TheDb1.CreateTable(KTempTblName, *colset2);
	TEST2(err, KErrNone);
	CleanupStack::PopAndDestroy(colset2);

	err = TheTbl2.Open(TheDb1, KTempTblName);
	TEST2(err, KErrNone);

	TheTbl2.InsertL();
	_LIT8(KTestData, "");
	TheTbl2.SetColL(2, KTestData);
	TheTbl2.PutL();
	
	TheTbl2.Close();
	err = TheTbl2.Open(TheDb1, KTempTblName);
	TEST2(err, KErrNone);
	res = TheTbl2.FirstL();
	TEST(res);
	TheTbl2.GetL();
	res = TheTbl2.IsColNull(2);
	TEST(res);
	TheTbl2.Close();
	
	TheTest.Next(_L("ColSize()"));	
	res = TheTbl1.FirstL();
	TEST(res);
	TheTbl1.GetL();
	res = TheTbl1.ColSize(1);
	TEST(res);
		
	TheTest.Next(_L("ColLength()"));	
	TInt len = TheTbl1.ColLength(1);
	TEST(len > 0);

	TheTbl1.InsertL();
	TheTbl1.SetColL(2, 3);
	TheTbl1.SetColL(3, 4);
	TheTbl1.PutL();

	TheTest.Next(_L("GotoL(TPosition)"));	
	res = TheTbl1.GotoL(RDbRowSet::EFirst);
	TEST(res);
	
	TheTest.Next(_L("Bookmark()/GotoL(TDbBookmark)"));	
	TDbBookmark bkmk = TheTbl1.Bookmark();
	res = TheTbl1.NextL();
	TEST(res);
	TheTbl1.GotoL(bkmk);
	TheTbl1.GetL();
	val1 = TheTbl1.ColInt32(1);
	TEST(val1 == 0);
	
	TheTest.Next(_L("CountL()/IsEmptyL()"));	
	cnt = TheTbl1.CountL();
	TEST(cnt == 2);
	res = TheTbl1.IsEmptyL();
	TEST(!res);
	
	TheTest.Next(_L("MatchL()"));	
	RDbRowConstraint match;
	CleanupClosePushL(match);
	err = match.Open(TheTbl1, TDbQuery(_L("ID > 0")));
	TEST2(err, KErrNone);
	res = EFalse;
	TheTbl1.BeginningL();
	while(TheTbl1.NextL())
		{
		if(TheTbl1.MatchL(match))
			{
			res = ETrue;
			}
		}
	CleanupStack::PopAndDestroy(&match);
	TEST(res);

	TheTest.Next(_L("FindL()"));	
	res = TheTbl1.FirstL();
	TEST(res);
	err = TheTbl1.FindL(RDbRowSet::EForwards, TDbQuery(_L("ID <> 0")));
	TEST(err >= 0);
	TheTbl1.GetL();
	val1 = TheTbl1.ColInt32(1);
	TEST(val1 > 0);

	_LIT8(KTestData2, "0123456789");
	HBufC8* buf = HBufC8::NewLC(10000);
	TPtr8 ptr = buf->Des(); 
	for(i=0;i<1000;++i)
		{
		ptr += KTestData2();
		}
	
	TheTest.Next(_L("RDbColReadStream"));	
	err = TheTbl2.Open(TheDb1, KTempTblName);
	TEST2(err, KErrNone);

	TheTbl2.InsertL();
	TheTbl2.SetColL(2, *buf);
	TheTbl2.PutL();
	
	TheTbl2.InsertL();
	TheTbl2.SetColL(2, KTestData2);
	TheTbl2.PutL();
	
	res = TheTbl2.PreviousL();
	TEST(res);
	TheTbl2.GetL();
	RDbColReadStream rstream;
	rstream.OpenLC(TheTbl2, 2);
	ptr.Zero();
	rstream.ReadL(ptr, ptr.MaxLength());
	CleanupStack::PopAndDestroy(&rstream);
	TEST(ptr.Length() == ptr.MaxLength());

	TheTest.Next(_L("RDbColWriteStream"));	
	TheTbl2.InsertL();
	RDbColWriteStream wstream;
	wstream.OpenLC(TheTbl2, 2);
	wstream.WriteL(ptr, ptr.Length());
	wstream.CommitL();
	CleanupStack::PopAndDestroy(&wstream);
	TheTbl2.PutL();
	
	TheTbl2.Close();
	CleanupStack::PopAndDestroy(buf);
			
	TheTbl1.Close();
	}

static void ViewTestL()
	{
	RDbView view;
	CleanupClosePushL(view);
	
	TheTest.Next(_L("Prepare()"));	
	TInt err = view.Prepare(TheDb1, TDbQuery(_L("SELECT * FROM ATbl")));
	TEST2(err, KErrNone);
	
	TheTest.Next(_L("Update()"));	
	TBool res = view.FirstL();
	TEST(res);
	view.GetL();
	view.UpdateL();
	view.SetColL(2, 100);
	view.SetColL(3, 200);
	view.PutL();
	
	CleanupStack::PopAndDestroy(&view);

	TheTest.Next(_L("Prepare() with an update sql"));	
	CleanupClosePushL(view);
	err = view.Prepare(TheDb1, TDbQuery(_L("UPDATE ATbl SET DATA1 = 400 WHERE ID = 0")));
	TEST2(err, KErrArgument);
	CleanupStack::PopAndDestroy(&view);
	}

/**
@SYMTestCaseID SYSLIB-DBMS-CT-0021
@SYMTestCaseDesc RDbTable method calls test for a secure shared database.
                 Every method of RDbTable class and its base class too, is called
				 and the result - asserted.
@SYMTestPriority High
@SYMTestActions  RDbTable method calls test.
@SYMTestExpectedResults The test must not fail.
@SYMREQ          REQ2429
                 DBMS shall provide an API to apply security policies to database tables.
*/
void DoTblTestL()
	{
	TheTest.Next(_L(" @SYMTestCaseID SYSLIB-DBMS-CT-0021 "));
	
	TDBSCUtils::DeleteDatabase(TheDbs, KSecureDbUid, KDb1Name);
	
	TheDb1.Close();
	TheDb1 = TDBSCUtils::CreateDatabase(TheDbs, KSecureDbUid, KDb1Name);

	CDbColSet* colset = TDBSCUtils::CreateColSetLC(KColumns);
	TInt err = TheDb1.CreateTable(KTableName1, *colset);
	TEST2(err, KErrNone);
	CleanupStack::PopAndDestroy(colset);

	TheTest.Next(_L("Table calls test"));	
	::TblCallTestL();
	
	TheTest.Next(_L("View test"));	
	::ViewTestL();
	
	TheDb1.Close();
	}