// Copyright (c) 2010 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:
// 
//
#include <e32test.h>
#include <bautils.h>
#include <sqldb.h>

///////////////////////////////////////////////////////////////////////////////////////

RSqlDatabase TheDb;
RTest TheTest(_L("t_sqlcorrupt test"));

_LIT(KTestDir, "c:\\test\\");

_LIT(KDbName, "c:[08770000]t_sqlcorrupt.db");
_LIT(KFullDbName, "c:\\private\\10281E17\\[08770000]t_sqlcorrupt.db");

_LIT(KDbName2, "c:[08770000]t_sqlcorrupt2.db");
_LIT(KFullDbName2, "c:\\private\\10281E17\\[08770000]t_sqlcorrupt2.db");

RFs TheFs;

///////////////////////////////////////////////////////////////////////////////////////

void DestroyTestEnv()
	{
	TheDb.Close();
	(void)RSqlDatabase::Delete(KDbName2);
	(void)RSqlDatabase::Delete(KDbName);
	TheFs.Close();
	}

///////////////////////////////////////////////////////////////////////////////////////
//Test macros and functions
void Check1(TInt aValue, TInt aLine)
	{
	if(!aValue)
		{
		DestroyTestEnv();
		RDebug::Print(_L("*** Boolean expression evaluated to false. Line %d\r\n"), aLine);
		TheTest(EFalse, aLine);
		}
	}
void Check2(TInt aValue, TInt aExpected, TInt aLine)
	{
	if(aValue != aExpected)
		{
		DestroyTestEnv();
		RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
		TheTest(EFalse, aLine);
		}
	}
#define TEST(arg) ::Check1((arg), __LINE__)
#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)

///////////////////////////////////////////////////////////////////////////////////////

enum TDbEncoding
	{
	EDbEncUtf16,
	EDbEncUtf8,
	};

void DoCorruptedSecureDbTest(TDbEncoding aEncoding)
	{
	(void)RSqlDatabase::Delete(KDbName);
	
	RSqlSecurityPolicy policy;
	TInt err = policy.Create(TSecurityPolicy::EAlwaysPass);
	TEST2(err, KErrNone);
	
	err = policy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, TSecurityPolicy::EAlwaysPass);
	TEST2(err, KErrNone);
	err = policy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, TSecurityPolicy::EAlwaysPass);
	TEST2(err, KErrNone);
	err = policy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, TSecurityPolicy::EAlwaysPass);
	TEST2(err, KErrNone);
	
	err = policy.SetPolicy(RSqlSecurityPolicy::ETable, _L("A"), RSqlSecurityPolicy::EWritePolicy, TSecurityPolicy::EAlwaysPass);
	TEST2(err, KErrNone);
	err = policy.SetPolicy(RSqlSecurityPolicy::ETable, _L("A"), RSqlSecurityPolicy::EReadPolicy, TSecurityPolicy::EAlwaysPass);
	TEST2(err, KErrNone);
	
	if(aEncoding == EDbEncUtf16)
		{
		err = TheDb.Create(KDbName, policy);
		}
	else
		{
		_LIT8(KConfig, "encoding = \"UTF-8\"");
		err = TheDb.Create(KDbName, policy, &KConfig);
		}
	TEST2(err, KErrNone);
	err = TheDb.Exec(_L("CREATE TABLE A(I INTEGER); INSERT INTO A VALUES(10)"));
	TEST(err >= 0);
	TheDb.Close();
	policy.Close();

	CFileMan* fm = NULL;
	TRAP(err, fm = CFileMan::NewL(TheFs));
	TEST2(err, KErrNone);
	
	//Make a copy of the database
	err = fm->Copy(KFullDbName, KFullDbName2);
	TEST2(err, KErrNone);
	//Get the database file size and calculate the iterations count.
	TEntry entry;
	err = TheFs.Entry(KFullDbName, entry);
	TEST2(err, KErrNone);
	const TInt KCorruptBlockLen = 19;
	const TInt KIterationCnt = entry.iSize / KCorruptBlockLen;
	//
	TBuf8<KCorruptBlockLen> invalidData;
	invalidData.SetLength(KCorruptBlockLen);
	invalidData.Fill(TChar(0xCC));
	//
	for(TInt i=0;i<KIterationCnt;++i)
		{
		TheTest.Printf(_L("% 4d\r"), i + 1);
		//Corrupt the database
		err = fm->Copy(KFullDbName2, KFullDbName);
		TEST2(err, KErrNone);
		RFile file;
		err = file.Open(TheFs, KFullDbName, EFileRead | EFileWrite);
		TEST2(err, KErrNone);
		err = file.Write(i * KCorruptBlockLen, invalidData);
		TEST2(err, KErrNone);
		file.Close();
		//Try to open the database and read the record
		TBool testPassed = EFalse;
		err = TheDb.Open(KDbName);
		if(err == KErrNone)
			{
			RSqlStatement stmt;
			err = stmt.Prepare(TheDb, _L("SELECT I FROM A"));
			if(err == KErrNone)
				{
				err = stmt.Next();
				if(err == KSqlAtRow)
					{
					TInt val = stmt.ColumnInt(0);
					if(val == 10)
						{
						testPassed = ETrue;
						err = KErrNone;
						}
					else
						{
						err = KErrGeneral;
						}
					}
				stmt.Close();
				}
			}

		TheDb.Close();
		(void)RSqlDatabase::Delete(KDbName);
		TheTest.Printf(_L("Iteration % 4d, err=%d\r\n"), i + 1, err);
		if(!testPassed)
			{
			TEST(err != KErrNone);
			}
		}//end of - for(TInt i=0;i<KIterationCnt;++i)

	delete fm;
	TheTest.Printf(_L("\r\n"));
	}

/**
@SYMTestCaseID          PDS-SQL-CT-4202
@SYMTestCaseDesc        Invalid UTF16 encoded secure database test.
@SYMTestPriority        High
@SYMTestActions         The test creates 16-bit encoded secure database with one table and one record.
						Then the test simulates a database corruption by writing 19 bytes with random values
						from "pos" to "pos + 19", where "pos" is a valid db file position, incremented by 19
						at the end of each test iteration.
@SYMTestExpectedResults Test must not fail
*/  
void CorruptedSecureDbTest16()
	{
	DoCorruptedSecureDbTest(EDbEncUtf16);
	}

/**
@SYMTestCaseID          PDS-SQL-CT-4202
@SYMTestCaseDesc        Invalid UTF8 encoded secure database test.
@SYMTestPriority        High
@SYMTestActions         The test creates 8-bit encoded secure database with one table and one record.
						Then the test simulates a database corruption by writing 19 bytes with random values
						from "pos" to "pos + 19", where "pos" is a valid db file position, incremented by 19
						at the end of each test iteration.
@SYMTestExpectedResults Test must not fail
*/  
void CorruptedSecureDbTest8()
	{
	DoCorruptedSecureDbTest(EDbEncUtf8);
	}

void CreateTestEnv()
    {
    TInt err = TheFs.Connect();
    TEST2(err, KErrNone);

    err = TheFs.MkDir(KTestDir);
    TEST(err == KErrNone || err == KErrAlreadyExists);

    err = TheFs.CreatePrivatePath(EDriveC);
    TEST(err == KErrNone || err == KErrAlreadyExists);
    }

void DoTestsL()
	{
	TheTest.Start(_L("@SYMTestCaseID:PDS-SQL-CT-4202 Corrupted UTF16 encoded secure database test"));
	CorruptedSecureDbTest16();
	
	TheTest.Next(_L("@SYMTestCaseID:PDS-SQL-CT-4203 Corrupted UTF8 encoded secure database test"));
	CorruptedSecureDbTest8();
	}

TInt E32Main()
	{
	TheTest.Title();
	
	CTrapCleanup* tc = CTrapCleanup::New();
	TheTest(tc != NULL);
	
	__UHEAP_MARK;
		
	CreateTestEnv();
	TRAPD(err, DoTestsL());
	DestroyTestEnv();
	TEST2(err, KErrNone);

	__UHEAP_MARKEND;
	
	TheTest.End();
	TheTest.Close();
	
	delete tc;

	User::Heap().Check();
	return KErrNone;
	}