// Copyright (c) 2009-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>

#ifdef _SQLPROFILER

#include <bautils.h>

#include "FileBuf64.h"

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

TBool TheOsCallTimeDetailedProfileEnabled = ETrue;//Needed because the RFileBuf64 source is included directly into this test

												  //nd the sql profiler is enabled (_SQLPROFILER is defined in the MMP file)

static RTest TheTest(_L("t_sqlfilebuf64 test"));

static RFs   TheFs;

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

_LIT(KTestFile, "c:\\test\\t_sqlfilebuf64.bin");

_LIT(KTestFile2, "\\test\\t_sqlfilebuf64_2.bin");

_LIT(KTestFile3, "c:\\test\\t_sqlfilebuf64_3.bin");

static TBuf8<1024> TheBuf;

static TFileName TheDbName;

static TInt TheProcessHandleCount = 0;

static TInt TheThreadHandleCount = 0;

static TInt TheAllocatedCellsCount = 0;

#ifdef _DEBUG

static const TInt KBurstRate = 100;

#endif

enum TOomTestType

	{

	EOomCreateTest,	

	EOomOpenTest,	

	EOomTempTest

	};

//Used in read/write OOM tests

const TUint8 KChar = 'A';

const TInt KPageSize = 32768;

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

void DeleteTestFiles()

	{

	if(TheDbName.Length() > 0)

		{

		(void)TheFs.Delete(TheDbName);

		}

	(void)TheFs.Delete(KTestFile3);

	(void)TheFs.Delete(KTestFile);

	}

void TestEnvDestroy()

	{

	DeleteTestFiles();

	TheFs.Close();

	}

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

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

//Test macros and functions

void Check1(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		TestEnvDestroy();

		RDebug::Print(_L("*** Line %d\r\n"), aLine);

		TheTest(EFalse, aLine);

		}

	}

void Check2(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		TestEnvDestroy();

		RDebug::Print(_L("*** Line %d, Expected result: %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__)

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

void TestEnvInit()

    {

	TInt err = TheFs.Connect();

	TEST2(err, KErrNone);

	err = TheFs.MkDir(KTestDir);

	TEST(err == KErrNone || err == KErrAlreadyExists);

	}

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

static void MarkHandles()

	{

	RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);

	}

static void MarkAllocatedCells()

	{

	TheAllocatedCellsCount = User::CountAllocCells();

	}

static void CheckAllocatedCells()

	{

	TInt allocatedCellsCount = User::CountAllocCells();

	TEST2(allocatedCellsCount, TheAllocatedCellsCount);

	}

static void CheckHandles()

	{

	TInt endProcessHandleCount;

	TInt endThreadHandleCount;

	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

	TEST2(TheProcessHandleCount, endProcessHandleCount);

	TEST2(TheThreadHandleCount, endThreadHandleCount);

	}

static void VerifyFileContent(const TDesC8& aPattern)

	{

	TheBuf.Zero();

	RFile64 file;

	TInt err = file.Open(TheFs, KTestFile, EFileShareReadersOrWriters);

	TEST2(err, KErrNone);

	TInt64 fsize;

	err = file.Size(fsize);

	TEST2(err, KErrNone);

	TEST2((TInt)fsize, aPattern.Length());

	err = file.Read(TheBuf, aPattern.Length());

	TEST2(err, KErrNone);

	file.Close();

	err = TheBuf.Compare(aPattern);

	TEST2(err, 0);

	}

static void VerifyFileContent(const TDesC8& aPattern, TInt64 aFilePos)

	{

	__ASSERT_DEBUG(aFilePos >= 0, User::Invariant());

	TheBuf.Zero();

	RFile64 file;

	TInt err = file.Open(TheFs, KTestFile, EFileShareReadersOrWriters);

	TEST2(err, KErrNone);

	err = file.Read(aFilePos, TheBuf, aPattern.Length());

	TEST2(err, KErrNone);

	file.Close();

	err = TheBuf.Compare(aPattern);

	TEST2(err, 0);

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4132

@SYMTestCaseDesc		RFileBuf64 write test 1.

						The test performs file write operations using RFileBuf64 class.

						The write positions are inside the buffer or right at the end of the buffer.

						The purpose of the test: to verify the logic of RFileBuf64::Write().

@SYMTestActions			RFileBuf64 write test 1.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		High

@SYMREQ					REQ12106

                        REQ12109

*/

void WriteTest1()

	{

	RFileBuf64 fbuf(1024);

	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);

	TEST2(err, KErrNone); 

    fbuf.ProfilerReset();

    //Zero write request

	err = fbuf.Write(0, _L8(""));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	TEST2(fbuf.iFileSizeCount, 0);

	//First write operation. After the operation the file buffer must countain 10 bytes.

	err = fbuf.Write(0, _L8("A123456789"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	TEST2(fbuf.iFileSizeCount, 1);

	//Second write operation. The offset is at the middle of the buffer.  Data length: 10;

	err = fbuf.Write(5, _L8("ZZZZZEEEEE"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	//Third write operation. The offset is at the end of the buffer.  Data length: 5;

	err = fbuf.Write(15, _L8("CCCCC"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	err = fbuf.Flush();

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 1);

	TEST2(fbuf.iFileFlushCount, 1);

	TEST2(fbuf.iFileWriteAmount, 20);

	TEST2(fbuf.iFileSizeCount, 1);

	fbuf.Close();

	VerifyFileContent(_L8("A1234ZZZZZEEEEECCCCC"));

	(void)TheFs.Delete(KTestFile);

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4133

@SYMTestCaseDesc		RFileBuf64 write test 2.

						The test performs file write operations using RFileBuf64 class.

						The write positions are beyound the end of the file but within the buffer capacity.

						The purpose of the test: to verify the logic of RFileBuf64::Write().

@SYMTestActions			RFileBuf64 write test 2.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		High

@SYMREQ					REQ12106

                        REQ12109

*/

void WriteTest2()

	{

	RFileBuf64 fbuf(1024);

	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);

	TEST2(err, KErrNone); 

    fbuf.ProfilerReset();

	//First write operation. After the operation the file buffer must countain 10 bytes.

	err = fbuf.Write(0, _L8("A123456789"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	TEST2(fbuf.iFileSizeCount, 1);

	//Second write operation. After the operation the file buffer must countain 10 + 10 zeros + 10 bytes.

	err = fbuf.Write(20, _L8("FFGGHHJJKK"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	TEST2(fbuf.iFileSizeCount, 1);

	err = fbuf.Flush();

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 1);

	TEST2(fbuf.iFileFlushCount, 1);

	TEST2(fbuf.iFileWriteAmount, 30);

	TEST2(fbuf.iFileSizeCount, 1);

	fbuf.Close();

	TBuf8<30> pattern;

	pattern.Append(_L8("A123456789"));

	pattern.AppendFill(TChar(0), 10);

	pattern.Append(_L8("FFGGHHJJKK"));

	VerifyFileContent(pattern);

	(void)TheFs.Delete(KTestFile);

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4134

@SYMTestCaseDesc		RFileBuf64 write test 3.

						The test performs file write operations using RFileBuf64 class.

						The write position is before the start of the buffer but there is room for move.

						The purpose of the test: to verify the logic of RFileBuf64::Write().

@SYMTestActions			RFileBuf64 write test 3.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		High

@SYMREQ					REQ12106

                        REQ12109

*/

void WriteTest3()

	{

	//Iteration 1: The file length is 0, the first operation is "write beyond the end"

	//Iteration 2: The file length is 30, the first write operation is within the file.

	for(TInt i=0;i<2;++i)

		{

		RFileBuf64 fbuf(1024);

		TInt err = i == 0 ? fbuf.Create(TheFs, KTestFile, EFileWrite) : fbuf.Open(TheFs, KTestFile, EFileWrite);

		TEST2(err, KErrNone); 

	    fbuf.ProfilerReset();

		//First write operation. The offset is not 0.  Data length: 10;

		err = fbuf.Write(20, _L8("A123456789"));

		TEST2(err, KErrNone); 

		TEST2(fbuf.iFileWriteCount, 0);

		TEST2(fbuf.iFileWriteAmount, 0);

		TEST2(fbuf.iFileSizeCount, 1);

		//Second write operation. The offset is 0.  Data length: 20;

		err = fbuf.Write(0, _L8("AASSDDFFRR**********"));

		TEST2(err, KErrNone); 

		TEST2(fbuf.iFileWriteCount, 0);

		TEST2(fbuf.iFileWriteAmount, 0);

		TEST2(fbuf.iFileSizeCount, 1);

		err = fbuf.Flush();

		TEST2(err, KErrNone); 

		TEST2(fbuf.iFileWriteCount, 1);

		TEST2(fbuf.iFileFlushCount, 1);

		TEST2(fbuf.iFileWriteAmount, 30);

		TEST2(fbuf.iFileSizeCount, 1);

		fbuf.Close();

		VerifyFileContent(_L8("AASSDDFFRR**********A123456789"));

		}

	(void)TheFs.Delete(KTestFile);

	}	

/**

@SYMTestCaseID			PDS-SQL-UT-4135

@SYMTestCaseDesc		RFileBuf64 write test 4.

						The test performs file write operations using RFileBuf64 class and verifies that

						that the pending write data will be stored in the file when the buffer is closed.

						The purpose of the test: to verify the logic of RFileBuf64::Write().

@SYMTestActions			RFileBuf64 write test 4.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		High

@SYMREQ					REQ12106

                        REQ12109

*/

void WriteTest4()

	{

	RFileBuf64 fbuf(1024);

	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);

	TEST2(err, KErrNone); 

    fbuf.ProfilerReset();

	// Data length: 10;

	err = fbuf.Write(0, _L8("A123456789"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	TEST2(fbuf.iFileSizeCount, 1);

	// Data length: 0;

	err = fbuf.Write(10, _L8(""));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	TEST2(fbuf.iFileSizeCount, 1);

	fbuf.Close();

	VerifyFileContent(_L8("A123456789"));

	(void)TheFs.Delete(KTestFile);

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4136

@SYMTestCaseDesc		RFileBuf64 write test 5.

						The test performs file write operations using RFileBuf64 class.

						The data is written before the start of the file buffer and is too big to fit in the buffer.

						The purpose of the test: to verify the logic of RFileBuf64::Write().

@SYMTestActions			RFileBuf64 write test 5.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		High

@SYMREQ					REQ12106

                        REQ12109

*/

void WriteTest5()

	{

	RFileBuf64 fbuf(20);

	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);

	TEST2(err, KErrNone); 

    fbuf.ProfilerReset();

	//First write operation. The offset is not 0.  Data length: 10;

	err = fbuf.Write(10, _L8("A123456789"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	TEST2(fbuf.iFileSizeCount, 1);

	//Second write operation. The offset is 0.  Data length: 12;

	err = fbuf.Write(0, _L8("ZZXXCCVVBBNN"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 1);

	TEST2(fbuf.iFileWriteAmount, 20);

	TEST2(fbuf.iFileSizeCount, 1);

	err = fbuf.Flush();

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 2);

	TEST2(fbuf.iFileFlushCount, 1);

	TEST2(fbuf.iFileWriteAmount, 20 + 12);

	TEST2(fbuf.iFileSizeCount, 1);

	fbuf.Close();

	VerifyFileContent(_L8("ZZXXCCVVBBNN23456789"));

	(void)TheFs.Delete(KTestFile);

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4137

@SYMTestCaseDesc		RFileBuf64 write test 6.

						The test performs file write operations using RFileBuf64 class.

						The data is written before the start of the file buffer and is too big to fit in the buffer.

						The purpose of the test: to verify the logic of RFileBuf64::Write().

@SYMTestActions			RFileBuf64 write test 6.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		High

@SYMREQ					REQ12106

                        REQ12109

*/

void WriteTest6()

	{

	RFileBuf64 fbuf(20);

	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);

	TEST2(err, KErrNone); 

	err = fbuf.Write(0, _L8("A123456789B123456789C123456789"));

	TEST2(err, KErrNone); 

	err = fbuf.Flush();

	TEST2(err, KErrNone); 

	fbuf.Close();

	VerifyFileContent(_L8("A123456789B123456789C123456789"));

	err = fbuf.Open(TheFs, KTestFile, EFileWrite);

	TEST2(err, KErrNone); 

    fbuf.ProfilerReset();

	//First write operation. The offset is not 0. Data length: 10;

	err = fbuf.Write(15, _L8("OOOOOOOOOO"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 0);

	TEST2(fbuf.iFileWriteAmount, 0);

	TEST2(fbuf.iFileSizeCount, 1);

	//Second write operation. The offset is 0. Data length: 15;

	err = fbuf.Write(0, _L8("TTTTTTTTTTTTTTT"));

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 1);

	TEST2(fbuf.iFileWriteAmount, 10);

	TEST2(fbuf.iFileSizeCount, 1);

	err = fbuf.Flush();

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileWriteCount, 2);

	TEST2(fbuf.iFileFlushCount, 1);

	TEST2(fbuf.iFileWriteAmount, 15 + 10);

	TEST2(fbuf.iFileSizeCount, 1);

	fbuf.Close();

	VerifyFileContent(_L8("TTTTTTTTTTTTTTTOOOOOOOOOO56789"));

	(void)TheFs.Delete(KTestFile);

	}

void PrepareReadTest()

	{

	RFile64 file;

	TInt err = file.Create(TheFs, KTestFile, EFileWrite);

	TEST2(err, KErrNone); 

	err = file.Write(_L8("A123456789ZZZZZZZZZZB-B-B-B-B-Y*Y*Y*Y*Y*"));

	TEST2(err, KErrNone); 

	err = file.Flush();

	TEST2(err, KErrNone); 

	file.Close();

	}

/**

@SYMTestCaseID			PDS-SQL-UT-4138

@SYMTestCaseDesc		RFileBuf64 read test 1.

						The test performs file read operations using RFileBuf64 class.

						Tested "read" operations:

							- Zero max length request;

							- Too big read request;

							- Read beyond the end of the file;

						The purpose of the test: to verify the logic of RFileBuf64::Read().

@SYMTestActions			RFileBuf64 read test 1.

@SYMTestExpectedResults Test must not fail

@SYMTestPriority		High

@SYMREQ					REQ12106

                        REQ12109

*/

void ReadTest1()

	{

	const TInt KBufMaxSize = 20;// This is half the file size

	RFileBuf64 fbuf(KBufMaxSize);

	TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead | EFileShareReadersOrWriters);

	TEST2(err, KErrNone);

    fbuf.ProfilerReset();

	//Zero max length request

    TUint8 buf1[1];

	TPtr8 ptr1(buf1, 0);

	err = fbuf.Read(0, ptr1);

	TEST2(err, KErrNone); 

	TEST2(fbuf.iFileReadCount, 0);

	TEST2(fbuf.iFileReadAmount, 0);

	TEST2(fbuf.iFileSizeCount, 0);