sl@0: // Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: #include <e32test.h>
sl@0: 
sl@0: #ifdef _SQLPROFILER
sl@0: 
sl@0: #include <bautils.h>
sl@0: #include "FileBuf64.h"
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: TBool TheOsCallTimeDetailedProfileEnabled = ETrue;//Needed because the RFileBuf64 source is included directly into this test
sl@0: 												  //nd the sql profiler is enabled (_SQLPROFILER is defined in the MMP file)
sl@0: 
sl@0: static RTest TheTest(_L("t_sqlfilebuf64 test"));
sl@0: static RFs   TheFs;
sl@0: 
sl@0: _LIT(KTestDir, "c:\\test\\");
sl@0: _LIT(KTestFile, "c:\\test\\t_sqlfilebuf64.bin");
sl@0: _LIT(KTestFile2, "\\test\\t_sqlfilebuf64_2.bin");
sl@0: _LIT(KTestFile3, "c:\\test\\t_sqlfilebuf64_3.bin");
sl@0: 
sl@0: static TBuf8<1024> TheBuf;
sl@0: static TFileName TheDbName;
sl@0: 
sl@0: static TInt TheProcessHandleCount = 0;
sl@0: static TInt TheThreadHandleCount = 0;
sl@0: static TInt TheAllocatedCellsCount = 0;
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: static const TInt KBurstRate = 100;
sl@0: #endif
sl@0: 
sl@0: enum TOomTestType
sl@0: 	{
sl@0: 	EOomCreateTest,	
sl@0: 	EOomOpenTest,	
sl@0: 	EOomTempTest
sl@0: 	};
sl@0: 
sl@0: //Used in read/write OOM tests
sl@0: const TUint8 KChar = 'A';
sl@0: const TInt KPageSize = 32768;
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void DeleteTestFiles()
sl@0: 	{
sl@0: 	if(TheDbName.Length() > 0)
sl@0: 		{
sl@0: 		(void)TheFs.Delete(TheDbName);
sl@0: 		}
sl@0: 	(void)TheFs.Delete(KTestFile3);
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	}
sl@0: 
sl@0: void TestEnvDestroy()
sl@0: 	{
sl@0: 	DeleteTestFiles();
sl@0: 	TheFs.Close();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Test macros and functions
sl@0: void Check1(TInt aValue, TInt aLine)
sl@0: 	{
sl@0: 	if(!aValue)
sl@0: 		{
sl@0: 		TestEnvDestroy();
sl@0: 		RDebug::Print(_L("*** Line %d\r\n"), aLine);
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: void Check2(TInt aValue, TInt aExpected, TInt aLine)
sl@0: 	{
sl@0: 	if(aValue != aExpected)
sl@0: 		{
sl@0: 		TestEnvDestroy();
sl@0: 		RDebug::Print(_L("*** Line %d, Expected result: %d, got: %d\r\n"), aLine, aExpected, aValue);
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: #define TEST(arg) ::Check1((arg), __LINE__)
sl@0: #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void TestEnvInit()
sl@0:     {
sl@0: 	TInt err = TheFs.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	err = TheFs.MkDir(KTestDir);
sl@0: 	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: static void MarkHandles()
sl@0: 	{
sl@0: 	RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);
sl@0: 	}
sl@0: 
sl@0: static void MarkAllocatedCells()
sl@0: 	{
sl@0: 	TheAllocatedCellsCount = User::CountAllocCells();
sl@0: 	}
sl@0: 
sl@0: static void CheckAllocatedCells()
sl@0: 	{
sl@0: 	TInt allocatedCellsCount = User::CountAllocCells();
sl@0: 	TEST2(allocatedCellsCount, TheAllocatedCellsCount);
sl@0: 	}
sl@0: 
sl@0: static void CheckHandles()
sl@0: 	{
sl@0: 	TInt endProcessHandleCount;
sl@0: 	TInt endThreadHandleCount;
sl@0: 	
sl@0: 	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
sl@0: 
sl@0: 	TEST2(TheProcessHandleCount, endProcessHandleCount);
sl@0: 	TEST2(TheThreadHandleCount, endThreadHandleCount);
sl@0: 	}
sl@0: 
sl@0: static void VerifyFileContent(const TDesC8& aPattern)
sl@0: 	{
sl@0: 	TheBuf.Zero();
sl@0: 	
sl@0: 	RFile64 file;
sl@0: 	TInt err = file.Open(TheFs, KTestFile, EFileShareReadersOrWriters);
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	TInt64 fsize;
sl@0: 	err = file.Size(fsize);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2((TInt)fsize, aPattern.Length());
sl@0: 	
sl@0: 	err = file.Read(TheBuf, aPattern.Length());
sl@0: 	TEST2(err, KErrNone);
sl@0: 	
sl@0: 	file.Close();
sl@0: 	
sl@0: 	err = TheBuf.Compare(aPattern);
sl@0: 	TEST2(err, 0);
sl@0: 	}
sl@0: 
sl@0: static void VerifyFileContent(const TDesC8& aPattern, TInt64 aFilePos)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aFilePos >= 0, User::Invariant());
sl@0: 	
sl@0: 	TheBuf.Zero();
sl@0: 	
sl@0: 	RFile64 file;
sl@0: 	TInt err = file.Open(TheFs, KTestFile, EFileShareReadersOrWriters);
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	err = file.Read(aFilePos, TheBuf, aPattern.Length());
sl@0: 	TEST2(err, KErrNone);
sl@0: 	
sl@0: 	file.Close();
sl@0: 	
sl@0: 	err = TheBuf.Compare(aPattern);
sl@0: 	TEST2(err, 0);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4132
sl@0: @SYMTestCaseDesc		RFileBuf64 write test 1.
sl@0: 						The test performs file write operations using RFileBuf64 class.
sl@0: 						The write positions are inside the buffer or right at the end of the buffer.
sl@0: 						The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0: @SYMTestActions			RFileBuf64 write test 1.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void WriteTest1()
sl@0: 	{
sl@0: 	RFileBuf64 fbuf(1024);
sl@0: 	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0: 	TEST2(err, KErrNone); 
sl@0:     fbuf.ProfilerReset();
sl@0:     
sl@0:     //Zero write request
sl@0: 	err = fbuf.Write(0, _L8(""));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0: 
sl@0: 	//First write operation. After the operation the file buffer must countain 10 bytes.
sl@0: 	err = fbuf.Write(0, _L8("A123456789"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	//Second write operation. The offset is at the middle of the buffer.  Data length: 10;
sl@0: 	err = fbuf.Write(5, _L8("ZZZZZEEEEE"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 
sl@0: 	//Third write operation. The offset is at the end of the buffer.  Data length: 5;
sl@0: 	err = fbuf.Write(15, _L8("CCCCC"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 
sl@0: 	err = fbuf.Flush();
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 1);
sl@0: 	TEST2(fbuf.iFileFlushCount, 1);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 20);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	fbuf.Close();
sl@0: 	
sl@0: 	VerifyFileContent(_L8("A1234ZZZZZEEEEECCCCC"));
sl@0: 
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4133
sl@0: @SYMTestCaseDesc		RFileBuf64 write test 2.
sl@0: 						The test performs file write operations using RFileBuf64 class.
sl@0: 						The write positions are beyound the end of the file but within the buffer capacity.
sl@0: 						The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0: @SYMTestActions			RFileBuf64 write test 2.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void WriteTest2()
sl@0: 	{
sl@0: 	RFileBuf64 fbuf(1024);
sl@0: 	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0: 	TEST2(err, KErrNone); 
sl@0:     fbuf.ProfilerReset();
sl@0: 
sl@0: 	//First write operation. After the operation the file buffer must countain 10 bytes.
sl@0: 	err = fbuf.Write(0, _L8("A123456789"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	//Second write operation. After the operation the file buffer must countain 10 + 10 zeros + 10 bytes.
sl@0: 	err = fbuf.Write(20, _L8("FFGGHHJJKK"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	err = fbuf.Flush();
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 1);
sl@0: 	TEST2(fbuf.iFileFlushCount, 1);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 30);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	fbuf.Close();
sl@0: 	
sl@0: 	TBuf8<30> pattern;
sl@0: 	pattern.Append(_L8("A123456789"));
sl@0: 	pattern.AppendFill(TChar(0), 10);
sl@0: 	pattern.Append(_L8("FFGGHHJJKK"));
sl@0: 	VerifyFileContent(pattern);
sl@0: 	
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4134
sl@0: @SYMTestCaseDesc		RFileBuf64 write test 3.
sl@0: 						The test performs file write operations using RFileBuf64 class.
sl@0: 						The write position is before the start of the buffer but there is room for move.
sl@0: 						The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0: @SYMTestActions			RFileBuf64 write test 3.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void WriteTest3()
sl@0: 	{
sl@0: 	//Iteration 1: The file length is 0, the first operation is "write beyond the end"
sl@0: 	//Iteration 2: The file length is 30, the first write operation is within the file.
sl@0: 	for(TInt i=0;i<2;++i)
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(1024);
sl@0: 		TInt err = i == 0 ? fbuf.Create(TheFs, KTestFile, EFileWrite) : fbuf.Open(TheFs, KTestFile, EFileWrite);
sl@0: 		TEST2(err, KErrNone); 
sl@0: 	    fbuf.ProfilerReset();
sl@0: 
sl@0: 		//First write operation. The offset is not 0.  Data length: 10;
sl@0: 		err = fbuf.Write(20, _L8("A123456789"));
sl@0: 		TEST2(err, KErrNone); 
sl@0: 		TEST2(fbuf.iFileWriteCount, 0);
sl@0: 		TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 		TEST2(fbuf.iFileSizeCount, 1);
sl@0: 		
sl@0: 		//Second write operation. The offset is 0.  Data length: 20;
sl@0: 		err = fbuf.Write(0, _L8("AASSDDFFRR**********"));
sl@0: 		TEST2(err, KErrNone); 
sl@0: 		TEST2(fbuf.iFileWriteCount, 0);
sl@0: 		TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 		TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 		err = fbuf.Flush();
sl@0: 		TEST2(err, KErrNone); 
sl@0: 		TEST2(fbuf.iFileWriteCount, 1);
sl@0: 		TEST2(fbuf.iFileFlushCount, 1);
sl@0: 		TEST2(fbuf.iFileWriteAmount, 30);
sl@0: 		TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 		fbuf.Close();
sl@0: 
sl@0: 		VerifyFileContent(_L8("AASSDDFFRR**********A123456789"));
sl@0: 		}
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	}	
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4135
sl@0: @SYMTestCaseDesc		RFileBuf64 write test 4.
sl@0: 						The test performs file write operations using RFileBuf64 class and verifies that
sl@0: 						that the pending write data will be stored in the file when the buffer is closed.
sl@0: 						The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0: @SYMTestActions			RFileBuf64 write test 4.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void WriteTest4()
sl@0: 	{
sl@0: 	RFileBuf64 fbuf(1024);
sl@0: 	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0: 	TEST2(err, KErrNone); 
sl@0:     fbuf.ProfilerReset();
sl@0: 
sl@0: 	// Data length: 10;
sl@0: 	err = fbuf.Write(0, _L8("A123456789"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	// Data length: 0;
sl@0: 	err = fbuf.Write(10, _L8(""));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	fbuf.Close();
sl@0: 	
sl@0: 	VerifyFileContent(_L8("A123456789"));
sl@0: 	
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4136
sl@0: @SYMTestCaseDesc		RFileBuf64 write test 5.
sl@0: 						The test performs file write operations using RFileBuf64 class.
sl@0: 						The data is written before the start of the file buffer and is too big to fit in the buffer.
sl@0: 						The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0: @SYMTestActions			RFileBuf64 write test 5.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void WriteTest5()
sl@0: 	{
sl@0: 	RFileBuf64 fbuf(20);
sl@0: 	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0: 	TEST2(err, KErrNone); 
sl@0:     fbuf.ProfilerReset();
sl@0: 
sl@0: 	//First write operation. The offset is not 0.  Data length: 10;
sl@0: 	err = fbuf.Write(10, _L8("A123456789"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	//Second write operation. The offset is 0.  Data length: 12, i.e. within the buffer - should have no write to the disk.
sl@0: 	err = fbuf.Write(0, _L8("ZZXXCCVVBBNN"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 	
sl@0: 	//Third write operation. The offet is 18. Data length: 5. The buffer should be written out to the file
sl@0: 	// after "ab" is appended to the buffer. The new buffe after being emptied should have data "cde".
sl@0: 	err = fbuf.Write(18, _L8("abcde"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 1);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 20);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	err = fbuf.Flush();
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 2);
sl@0: 	TEST2(fbuf.iFileFlushCount, 1);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 23);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	fbuf.Close();
sl@0: 
sl@0: 	VerifyFileContent(_L8("ZZXXCCVVBBNN234567abcde"));
sl@0: 	
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4137
sl@0: @SYMTestCaseDesc		RFileBuf64 write test 6.
sl@0: 						The test performs file write operations using RFileBuf64 class.
sl@0: 						The data is written before the start of the file buffer and is too big to fit in the buffer.
sl@0: 						The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0: @SYMTestActions			RFileBuf64 write test 6.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void WriteTest6()
sl@0: 	{
sl@0: 	RFileBuf64 fbuf(20);
sl@0: 	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 
sl@0: 	err = fbuf.Write(0, _L8("A123456789B123456789C123456789"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	err = fbuf.Flush();
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	fbuf.Close();
sl@0: 	VerifyFileContent(_L8("A123456789B123456789C123456789"));
sl@0: 
sl@0: 	err = fbuf.Open(TheFs, KTestFile, EFileWrite);
sl@0: 	TEST2(err, KErrNone); 
sl@0:     fbuf.ProfilerReset();
sl@0: 
sl@0: 	//First write operation. The offset is not 0. Data length: 10;
sl@0: 	err = fbuf.Write(15, _L8("OOOOOOOOOO"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	//Second write operation. The offset is 0. Data length: 15;
sl@0: 	err = fbuf.Write(0, _L8("TTTTTTTTTTTTTTT"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 1);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 10);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	err = fbuf.Flush();
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileWriteCount, 2);
sl@0: 	TEST2(fbuf.iFileFlushCount, 1);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 15 + 10);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 
sl@0: 	fbuf.Close();
sl@0: 
sl@0: 	VerifyFileContent(_L8("TTTTTTTTTTTTTTTOOOOOOOOOO56789"));
sl@0: 	
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	}
sl@0: 
sl@0: void PrepareReadTest()
sl@0: 	{
sl@0: 	RFile64 file;
sl@0: 	TInt err = file.Create(TheFs, KTestFile, EFileWrite);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	err = file.Write(_L8("A123456789ZZZZZZZZZZB-B-B-B-B-Y*Y*Y*Y*Y*"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	err = file.Flush();
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	file.Close();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4138
sl@0: @SYMTestCaseDesc		RFileBuf64 read test 1.
sl@0: 						The test performs file read operations using RFileBuf64 class.
sl@0: 						Tested "read" operations:
sl@0: 							- Zero max length request;
sl@0: 							- Too big read request;
sl@0: 							- Read beyond the end of the file;
sl@0: 						The purpose of the test: to verify the logic of RFileBuf64::Read().
sl@0: @SYMTestActions			RFileBuf64 read test 1.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void ReadTest1()
sl@0: 	{
sl@0: 	const TInt KBufMaxSize = 20;// This is half the file size
sl@0: 	RFileBuf64 fbuf(KBufMaxSize);
sl@0: 	TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead | EFileShareReadersOrWriters);
sl@0: 	TEST2(err, KErrNone);
sl@0:     fbuf.ProfilerReset();
sl@0:     
sl@0: 	//Zero max length request
sl@0:     TUint8 buf1[1];
sl@0: 	TPtr8 ptr1(buf1, 0);
sl@0: 	err = fbuf.Read(0, ptr1);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 0);
sl@0: 	TEST2(fbuf.iFileReadAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0: 
sl@0: 	//Too big request
sl@0: 	TBuf8<KBufMaxSize * 2> buf2;
sl@0: 	err = fbuf.Read(0, buf2);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 1);
sl@0: 	TEST2(fbuf.iFileReadAmount, (KBufMaxSize * 2));
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0: 	VerifyFileContent(buf2);
sl@0: 	
sl@0: 	//Read beyond the end of the file
sl@0: 	err = fbuf.Read(2000, buf2);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(buf2.Length(), 0); 
sl@0: 
sl@0: 	//Write "5678" in the buffer, pos [4..8)
sl@0: 	err = fbuf.Write(4, _L8("5678"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 
sl@0: 	//Too big request. There are pending data in the buffer.
sl@0: 	TBuf8<KBufMaxSize + 2> buf3;
sl@0: 	err = fbuf.Read(1, buf3);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	VerifyFileContent(buf3, 1);
sl@0: 
sl@0: 	//Read from a non-zero file position to move the buffer start pos. The cached file pos will be 35 at the end.
sl@0: 	TBuf8<5> buf4;
sl@0: 	err = fbuf.Read(30, buf4);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	VerifyFileContent(buf4, 30);
sl@0: 	err = fbuf.Read(35, buf4);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	VerifyFileContent(buf4, 35);
sl@0: 
sl@0: 	//Too big request. No pending data in the buffer. The file read pos is before the position of the cached data in the buffer.  
sl@0: 	err = fbuf.Read(10, buf3);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	VerifyFileContent(buf3, 10);
sl@0: 	
sl@0: 	fbuf.Close();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4139
sl@0: @SYMTestCaseDesc		RFileBuf64 read test 2.
sl@0: 						The test performs file read operations using RFileBuf64 class.
sl@0: 						Tested operations:
sl@0: 							- Non-buffered reads;
sl@0: 							- Buffered reads;
sl@0: 						The purpose of the test: to verify the logic of RFileBuf64::Read().
sl@0: @SYMTestActions			RFileBuf64 read test 2.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void ReadTest2()
sl@0: 	{
sl@0: 	RFileBuf64 fbuf(1024);
sl@0: 	TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead | EFileShareReadersOrWriters);
sl@0: 	TEST2(err, KErrNone); 
sl@0:     fbuf.ProfilerReset();
sl@0:     
sl@0:     //1. Read bytes [0..20]
sl@0:     TBuf8<20> buf1;
sl@0: 	err = fbuf.Read(0, buf1);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 1);
sl@0: 	TEST2(fbuf.iFileReadAmount, 20);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf1, 0);
sl@0:     
sl@0:     //2. Read again, bytes [10..20]. They are not buffered.
sl@0:     TBuf8<10> buf2;
sl@0: 	err = fbuf.Read(10, buf2);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 1);
sl@0: 	TEST2(fbuf.iFileReadAmount, 10);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf2, 10);
sl@0: 
sl@0:     //3. Read again, bytes [20..30]. They are not buffered. But the file buffer will be populated, 
sl@0:     //   because the file read position matches the guessed file read position from step 2.
sl@0: 	err = fbuf.Read(20, buf2);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 1);
sl@0: 	TEST2(fbuf.iFileReadAmount, (10 * 2));
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf2, 20);
sl@0: 
sl@0: 	//4. Read again, bytes [25..35]. This is a buffered read operation.
sl@0: 	err = fbuf.Read(25, buf2);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 0);
sl@0: 	TEST2(fbuf.iFileReadAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf2, 25);
sl@0: 	
sl@0: 	//5. Read again, bytes [15..25]. This is a non buffered read operation.
sl@0: 	err = fbuf.Read(15, buf2);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 1);
sl@0: 	TEST2(fbuf.iFileReadAmount, 10);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf2, 15);
sl@0: 
sl@0:     //6. Read again, bytes [25..35]. This is a buffered read operation. The buffer from step 3 is still there.
sl@0: 	err = fbuf.Read(25, buf2);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 0);
sl@0: 	TEST2(fbuf.iFileReadAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf2, 25);
sl@0: 	
sl@0:     //7. Read again, bytes [35..45] - beyond the end of the file. 
sl@0:     //   This is a buffered read operation. The buffer from step 3 is still there.
sl@0: 	err = fbuf.Read(35, buf2);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 0);
sl@0: 	TEST2(fbuf.iFileReadAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0: 	TEST2(buf2.Size(), 5);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf2, 35);
sl@0: 	
sl@0: 	fbuf.Close();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4140
sl@0: @SYMTestCaseDesc		RFileBuf64 read test 3.
sl@0: 						The test performs file read operations using RFileBuf64 class.
sl@0: 						Tested operations:
sl@0: 							- Non-buffered reads;
sl@0: 							- Buffered reads;
sl@0: 							- Part- buffered reads;
sl@0: 						The purpose of the test: to verify the logic of RFileBuf64::Read().
sl@0: @SYMTestActions			RFileBuf64 read test 3.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void ReadTest3()
sl@0: 	{
sl@0: 	RFileBuf64 fbuf(1024);
sl@0: 	TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead | EFileShareReadersOrWriters);
sl@0: 	TEST2(err, KErrNone); 
sl@0:     fbuf.ProfilerReset();
sl@0:     
sl@0:     //1. Read bytes [0..10]. Non buffered.
sl@0:     TBuf8<10> buf1;
sl@0: 	err = fbuf.Read(0, buf1);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 1);
sl@0: 	TEST2(fbuf.iFileReadAmount, 10);
sl@0: 	TEST2(fbuf.iFileSizeCount, 1);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf1, 0);
sl@0: 
sl@0:     //2. Read bytes [10..20]. Non buffered. But the file buffer is populated, bytes [10..40].
sl@0: 	err = fbuf.Read(10, buf1);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 1);
sl@0: 	TEST2(fbuf.iFileReadAmount, 30);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf1, 10);
sl@0: 	
sl@0:     //3. Read bytes [25..35]. Buffered. Because the previous operation [2] performed a read-ahead operation.
sl@0: 	err = fbuf.Read(25, buf1);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 0);
sl@0: 	TEST2(fbuf.iFileReadAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf1, 25);
sl@0: 
sl@0:     //4. Write bytes [20..30]. Buffered. Read buffer is gone, the file buffer contains the [20..30] file area.
sl@0: 	err = fbuf.Write(20, _L8("IIIIIQQQQQ"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 0);
sl@0: 	TEST2(fbuf.iFileReadAmount, 0);
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 
sl@0:     //5. Read bytes [25..35]. Part-buffered. Part of pending writes picked up. Then the buffer is flushed.
sl@0: 	err = fbuf.Read(25, buf1);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 1);
sl@0: 	TEST2(fbuf.iFileReadAmount, 5);
sl@0: 	TEST2(fbuf.iFileWriteCount, 1);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 10);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0: 	
sl@0:     fbuf.ProfilerReset();
sl@0:     err = fbuf.Flush();
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     //All cached data should have been written to the file before the Flush() call.
sl@0: 	TEST2(fbuf.iFileReadCount, 0);
sl@0: 	TEST2(fbuf.iFileReadAmount, 0);
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0: 	TEST2(fbuf.iFileFlushCount, 1);
sl@0:     
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf1, 25);
sl@0: 
sl@0:     //6. The buffer is empty after the last flush. Write bytes [0..10]. The file buffer contains the [0..10] file area.
sl@0: 	err = fbuf.Write(0, _L8("PPOOIIUUYY"));
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 0);
sl@0: 	TEST2(fbuf.iFileReadAmount, 0);
sl@0: 	TEST2(fbuf.iFileWriteCount, 0);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 0);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 	
sl@0:     //7. Read bytes [5..15]. Part buffered. Pending writes picked up. The content is written to the file.
sl@0: 	err = fbuf.Read(5, buf1);
sl@0: 	TEST2(err, KErrNone); 
sl@0: 	TEST2(fbuf.iFileReadCount, 1);
sl@0: 	TEST2(fbuf.iFileReadAmount, 5);
sl@0: 	TEST2(fbuf.iFileWriteCount, 1);
sl@0: 	TEST2(fbuf.iFileWriteAmount, 10);
sl@0: 	TEST2(fbuf.iFileSizeCount, 0);
sl@0:     fbuf.ProfilerReset();
sl@0: 	VerifyFileContent(buf1, 5);
sl@0: 	
sl@0: 	fbuf.Close();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4141
sl@0: @SYMTestCaseDesc		RFileBuf64::SetReadAheadSize() test.
sl@0: 						The test iterates over all existing drives.
sl@0: 						For each R/W drive a test file is created using RFileBuf64 class.
sl@0: 						Then the test collects information regarding the block size, cluster size and 
sl@0: 						read buffer size and calls RFileBuf64::SetReadAheadSize() with these parameters
sl@0: 						to check how the read-ahead buffer size will be recalculated.
sl@0: @SYMTestActions			RFileBuf64::SetReadAheadSize() test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void SetReadAheadSizeTest()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("==================\r\n"));
sl@0: 	_LIT(KType1, "Not present");
sl@0: 	_LIT(KType2, "Unknown");
sl@0: 	_LIT(KType3, "Floppy");
sl@0: 	_LIT(KType4, "Hard disk");
sl@0: 	_LIT(KType5, "CD ROM");
sl@0: 	_LIT(KType6, "RAM disk");
sl@0: 	_LIT(KType7, "Flash");
sl@0: 	_LIT(KType8, "ROM drive");
sl@0: 	_LIT(KType9, "Remote drive");
sl@0: 	_LIT(KType10,"NAND flash");
sl@0: 	_LIT(KType11,"Rotating media");
sl@0: 	
sl@0: 	for(TInt drive=EDriveA;drive<=EDriveZ;++drive)
sl@0: 		{
sl@0: 		TDriveInfo driveInfo;
sl@0: 		TInt err = TheFs.Drive(driveInfo, drive);
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			TVolumeInfo vinfo;
sl@0: 			err = TheFs.Volume(vinfo, drive);
sl@0: 			if(err == KErrNone)
sl@0: 				{
sl@0: 				TVolumeIOParamInfo vparam;
sl@0: 				err = TheFs.VolumeIOParam(drive, vparam);
sl@0: 				TEST2(err, KErrNone);
sl@0: 				TBuf8<128> vinfoex8;
sl@0: 				err = TheFs.QueryVolumeInfoExt(drive, EFileSystemSubType, vinfoex8);
sl@0: 				TEST2(err, KErrNone);
sl@0: 				TPtrC vinfoex((const TUint16*)(vinfoex8.Ptr() + 8), vinfoex8[0]);
sl@0: 				TPtrC KMediaTypeNames[] = {KType1(), KType2(), KType3(), KType4(), KType5(), KType6(), KType7(), KType8(), KType9(), KType10(), KType11()};
sl@0: 				TheTest.Printf(_L("Drive: %C:, Type: %16.16S, File System: %8.8S, Size: %d Mb.\r\n"), 'A' + drive, &KMediaTypeNames[driveInfo.iType], &vinfoex, (TInt)(vinfo.iSize / (1024 * 1024)));
sl@0: 				TheTest.Printf(_L("            Size: %ld bytes.\r\n"), vinfo.iSize);
sl@0: 				TheTest.Printf(_L("       Block size=%d, Cluster size=%d, Read buffer size=%d.\r\n"), vparam.iBlockSize, vparam.iClusterSize, vparam.iRecReadBufSize);
sl@0: 				if(driveInfo.iType == EMediaRam || driveInfo.iType == EMediaHardDisk || driveInfo.iType == EMediaFlash || driveInfo.iType == EMediaNANDFlash)
sl@0: 				  	{
sl@0: 					TDriveUnit drvUnit(drive);
sl@0: 					TDriveName drvName = drvUnit.Name();
sl@0: 					TParse parse;
sl@0: 					parse.Set(KTestFile2, &drvName, NULL);
sl@0: 					TheDbName.Copy(parse.FullName());
sl@0: 					TRAP(err, BaflUtils::EnsurePathExistsL(TheFs, TheDbName));
sl@0: 					if(err == KErrNone || err == KErrAlreadyExists)
sl@0: 						{
sl@0: 						(void)TheFs.Delete(TheDbName);
sl@0: 						RFileBuf64 fbuf64(8 * 1024);
sl@0: 						err = fbuf64.Create(TheFs, TheDbName, EFileRead | EFileWrite);
sl@0: 						TEST2(err, KErrNone);
sl@0: 						TInt readAhead = fbuf64.SetReadAheadSize(vparam.iBlockSize, vparam.iRecReadBufSize);
sl@0: 						TheTest.Printf(_L("       Read-ahead size=%d.\r\n"), readAhead);
sl@0: 						fbuf64.Close();
sl@0: 						(void)TheFs.Delete(TheDbName);
sl@0: 						}
sl@0: 					else
sl@0: 						{
sl@0: 						TheTest.Printf(_L("Drive %C. BaflUtils::EnsurePathExistsL() has failed with err=%d.\r\n"), 'A' + drive, err);	
sl@0: 						}
sl@0: 					}
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				TheTest.Printf(_L("Drive %C. RFs::Volume() has failed with err=%d.\r\n"), 'A' + drive, err);	
sl@0: 				}
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TheTest.Printf(_L("Drive %C. RFs::Drive() has failed with err=%d.\r\n"), 'A' + drive, err);	
sl@0: 			}
sl@0: 		}
sl@0: 	TheTest.Printf(_L("==================\r\n"));
sl@0: 	//
sl@0: 	RFileBuf64 fbuf64(8 * 1024);//buffer capacity = 8Kb
sl@0: 	
sl@0: 	//"ReadRecBufSize" defined and is power of two, the "BlockSize" is also defined and is power of two
sl@0: 	TInt err2 = fbuf64.Create(TheFs, TheDbName, EFileRead | EFileWrite);
sl@0: 	TEST2(err2, KErrNone);
sl@0: 	TInt blockSize = 4096; TInt readRecBufSize = 2048;
sl@0: 	TInt readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0: 	TEST2(readAhead2, readRecBufSize);
sl@0: 	fbuf64.Close();
sl@0: 	
sl@0: 	//"ReadRecBufSize" defined and is power of two but is less than the default read-ahead value
sl@0: 	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
sl@0: 	TEST2(err2, KErrNone);
sl@0: 	blockSize = 0; readRecBufSize = 128;
sl@0: 	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0: 	TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
sl@0: 	fbuf64.Close();
sl@0: 	
sl@0: 	//"ReadRecBufSize" defined and is power of two but is bigger than the buffer capacity
sl@0: 	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
sl@0: 	TEST2(err2, KErrNone);
sl@0: 	blockSize = -10; readRecBufSize = fbuf64.iCapacity * 2;
sl@0: 	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0: 	TEST2(readAhead2, fbuf64.iCapacity);
sl@0: 	fbuf64.Close();
sl@0: 	
sl@0: 	//"ReadRecBufSize" defined but is not power of two, "BlockSize" defined but is less than the default read-ahead value
sl@0: 	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
sl@0: 	TEST2(err2, KErrNone);
sl@0: 	blockSize = 512; readRecBufSize = 4000;
sl@0: 	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0: 	TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
sl@0: 	fbuf64.Close();
sl@0: 	
sl@0: 	//"ReadRecBufSize" defined but is not power of two, "BlockSize" defined and is bigger than the default read-ahead value
sl@0: 	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
sl@0: 	TEST2(err2, KErrNone);
sl@0: 	blockSize = 4096; readRecBufSize = 4000;
sl@0: 	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0: 	TEST2(readAhead2, blockSize);
sl@0: 	fbuf64.Close();
sl@0: 
sl@0: 	//"ReadRecBufSize" defined but is not power of two, "BlockSize" defined and is bigger than the buffer capacity
sl@0: 	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
sl@0: 	TEST2(err2, KErrNone);
sl@0: 	blockSize = fbuf64.iCapacity * 2; readRecBufSize = 1;
sl@0: 	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0: 	TEST2(readAhead2, fbuf64.iCapacity);
sl@0: 	fbuf64.Close();
sl@0: 	
sl@0: 	//"ReadRecBufSize" negative, "BlockSize" defined but is not power of two
sl@0: 	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
sl@0: 	TEST2(err2, KErrNone);
sl@0: 	blockSize = 1000; readRecBufSize = -2;
sl@0: 	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0: 	TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
sl@0: 	fbuf64.Close();
sl@0: 	
sl@0: 	//"ReadRecBufSize" negative, "BlockSize" negative
sl@0: 	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
sl@0: 	TEST2(err2, KErrNone);
sl@0: 	blockSize = -1; readRecBufSize = -2;
sl@0: 	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0: 	TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
sl@0: 	fbuf64.Close();
sl@0: 	//
sl@0: 	(void)TheFs.Delete(TheDbName);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4142
sl@0: @SYMTestCaseDesc		RFileBuf64 OOM test.
sl@0: 						The test calls RFileBuf64:Create(), RFileBuf64:Open() and RFileBuf64:Temp() in an OOM
sl@0: 						simulation loop and verifies that no memory is leaked.
sl@0: @SYMTestActions			RFileBuf64 OOM test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMREQ					REQ12106
sl@0:                         REQ12109
sl@0: */
sl@0: void OomTest(TOomTestType aOomTestType)
sl@0: 	{
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	
sl@0: 	if(aOomTestType == EOomOpenTest)
sl@0: 		{
sl@0: 		RFile64 file;
sl@0: 		TInt err2 = file.Create(TheFs, KTestFile, EFileWrite | EFileRead);	
sl@0: 		file.Close();
sl@0: 		TEST2(err2, KErrNone);
sl@0: 		}
sl@0: 	
sl@0: 	TFileName tmpFileName;
sl@0: 	TInt err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	RFileBuf64 fbuf(1024);
sl@0: 	TheTest.Printf(_L("Iteration:\r\n"));
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0: 		
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 		
sl@0: 		__UHEAP_MARK;
sl@0: 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
sl@0: 		
sl@0: 		switch(aOomTestType)
sl@0: 			{
sl@0: 			case EOomCreateTest:
sl@0: 				err = fbuf.Create(TheFs, KTestFile, EFileWrite | EFileRead);
sl@0: 				break;
sl@0: 			case EOomOpenTest:
sl@0: 				err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead);
sl@0: 				break;
sl@0: 			case EOomTempTest:
sl@0: 				{
sl@0: 				err = fbuf.Temp(TheFs, KTestDir, tmpFileName, EFileWrite | EFileRead);
sl@0: 				}
sl@0: 				break;
sl@0: 			default:
sl@0: 				TEST(0);
sl@0: 				break;
sl@0: 			}
sl@0: 		fbuf.Close();
sl@0: 		
sl@0: 		__UHEAP_RESET;
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();
sl@0: 		CheckHandles();
sl@0: 		
sl@0: 		TEntry entry;
sl@0: 		if(err != KErrNoMemory)
sl@0: 			{
sl@0: 			TEST2(err, KErrNone);	
sl@0: 			}
sl@0: 		else if(aOomTestType == EOomCreateTest)
sl@0: 			{
sl@0: 			TInt err2 = TheFs.Entry(KTestFile, entry);
sl@0: 			TEST2(err2, KErrNotFound);
sl@0: 			}
sl@0: 		else if(aOomTestType == EOomTempTest)
sl@0: 			{
sl@0: 			if(tmpFileName.Size() > 0)
sl@0: 				{
sl@0: 				TInt err2 = TheFs.Entry(tmpFileName, entry);
sl@0: 				TEST2(err2, KErrNotFound);
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0: 	
sl@0: 	if(aOomTestType == EOomTempTest)
sl@0: 		{
sl@0: 		(void)TheFs.Delete(tmpFileName);
sl@0: 		}
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4195
sl@0: @SYMTestCaseDesc		RFileBuf64::Create() file I/O error simulation test.
sl@0: 						The test calls RFileBuf64:Create() in a file I/O error simulation loop.
sl@0: @SYMTestActions			RFileBuf64::Create() file I/O error simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMDEF					DEF145198
sl@0: */
sl@0: void CreateFileIoErrTest()
sl@0: 	{
sl@0:     TInt err = KErrGeneral;
sl@0:     TInt cnt = 0;
sl@0:     for(;err<KErrNone;++cnt)
sl@0:         {
sl@0:         TheTest.Printf(_L("===Iteration %d. Simulated error:\r\n"), cnt);       
sl@0:         for (TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
sl@0:             {
sl@0:             TheTest.Printf(_L("%d "), fsError);
sl@0:         	__UHEAP_MARK;
sl@0:             (void)TheFs.SetErrorCondition(fsError, cnt);
sl@0:         	RFileBuf64 fbuf(1024);//buffer capacity = 1024 bytes
sl@0:         	err = fbuf.Create(TheFs, KTestFile3, EFileRead | EFileWrite);
sl@0:             (void)TheFs.SetErrorCondition(KErrNone);
sl@0:             fbuf.Close();
sl@0:             __UHEAP_MARKEND;
sl@0: 			TInt err2 = TheFs.Delete(KTestFile3);
sl@0: 			TInt expectedErr = err == KErrNone ? KErrNone : KErrNotFound;
sl@0: 			TEST2(err2, expectedErr);
sl@0:             }
sl@0:         TheTest.Printf(_L("\r\n"));
sl@0:         }
sl@0:     TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\n"), cnt);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4196
sl@0: @SYMTestCaseDesc		RFileBuf64::Open() file I/O error simulation test.
sl@0: 						The test calls RFileBuf64:Open() in a file I/O error simulation loop.
sl@0: @SYMTestActions			RFileBuf64::Open() file I/O error simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMDEF					DEF145198
sl@0: */
sl@0: void OpenFileIoErrTest()
sl@0: 	{
sl@0: 	RFileBuf64 fbuf(1024);//buffer capacity = 1024 bytes
sl@0: 	TInt err = fbuf.Create(TheFs, KTestFile3, EFileRead | EFileWrite);
sl@0: 	fbuf.Close();
sl@0: 	TEST2(err, KErrNone);
sl@0:     err = KErrGeneral;
sl@0:     TInt cnt = 0;
sl@0:     for(;err<KErrNone;++cnt)
sl@0:         {
sl@0:         TheTest.Printf(_L("===Iteration %d. Simulated error:\r\n"), cnt);       
sl@0:         for (TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
sl@0:             {
sl@0:             TheTest.Printf(_L("%d "), fsError);
sl@0:         	__UHEAP_MARK;
sl@0:             (void)TheFs.SetErrorCondition(fsError, cnt);
sl@0:         	err = fbuf.Open(TheFs, KTestFile3, EFileRead | EFileWrite);
sl@0:             (void)TheFs.SetErrorCondition(KErrNone);
sl@0:             fbuf.Close();
sl@0:             __UHEAP_MARKEND;
sl@0:             }
sl@0:         TheTest.Printf(_L("\r\n"));
sl@0:         }
sl@0:     TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\n"), cnt);
sl@0: 	(void)TheFs.Delete(KTestFile3);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4197
sl@0: @SYMTestCaseDesc		RFileBuf64::Temp() file I/O error simulation test.
sl@0: 						The test calls RFileBuf64:Temp() in a file I/O error simulation loop.
sl@0: @SYMTestActions			RFileBuf64::temp() file I/O error simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMDEF					DEF145198
sl@0: */
sl@0: void TempFileIoErrTest()
sl@0: 	{
sl@0:     TInt err = KErrGeneral;
sl@0:     TInt cnt = 0;
sl@0:     for(;err<KErrNone;++cnt)
sl@0:         {
sl@0:         TheTest.Printf(_L("===Iteration %d. Simulated error:\r\n"), cnt);       
sl@0:         for (TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
sl@0:             {
sl@0:             TheTest.Printf(_L("%d "), fsError);
sl@0:         	__UHEAP_MARK;
sl@0:             (void)TheFs.SetErrorCondition(fsError, cnt);
sl@0:         	RFileBuf64 fbuf(1024);//buffer capacity = 1024 bytes
sl@0:         	TFileName tmpFileName;
sl@0: 			err = fbuf.Temp(TheFs, KTestDir, tmpFileName, EFileWrite | EFileRead);
sl@0:             (void)TheFs.SetErrorCondition(KErrNone);
sl@0:             fbuf.Close();
sl@0:             __UHEAP_MARKEND;
sl@0: 			TInt err2 = TheFs.Delete(tmpFileName);
sl@0: 			TInt expectedErr = err == KErrNone ? KErrNone : KErrNotFound;
sl@0: 			TEST2(err2, expectedErr);
sl@0:             }
sl@0:         TheTest.Printf(_L("\r\n"));
sl@0:         }
sl@0:     TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\n"), cnt);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4207
sl@0: @SYMTestCaseDesc		RFileBuf64::Write() OOM test.
sl@0: 						The test calls RFileBuf64:Write() in an OOM
sl@0: 						simulation loop and verifies that no memory is leaked.
sl@0: 						The test also check that RFileBuf::DoSetCapacity() correctly operates in
sl@0: 						"out of memory" situation.
sl@0: @SYMTestActions			RFileBuf64::Write() OOM test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMDEF					380056
sl@0: */
sl@0: void WriteOomTest()
sl@0: 	{
sl@0: 	HBufC8* databuf = HBufC8::New(KPageSize);
sl@0: 	TEST(databuf != NULL);
sl@0: 	TPtr8 dataptr = databuf->Des();
sl@0: 	dataptr.SetLength(KPageSize);
sl@0: 	dataptr.Fill(TChar(KChar));
sl@0: 	
sl@0: 	TInt err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	TheTest.Printf(_L("Iteration:\r\n"));
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0: 
sl@0: 		(void)TheFs.Delete(KTestFile);
sl@0: 		
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 		
sl@0: 		__UHEAP_MARK;
sl@0: 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
sl@0: 
sl@0: 		const TInt KDefaultBufCapacity = 1024;
sl@0: 		RFileBuf64 fbuf(KDefaultBufCapacity);
sl@0: 		err = fbuf.Create(TheFs, KTestFile, EFileWrite | EFileRead);
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = fbuf.Write(0LL, dataptr);
sl@0: 			}
sl@0: 		fbuf.Close();
sl@0: 		
sl@0: 		__UHEAP_RESET;
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();
sl@0: 		CheckHandles();
sl@0: 		}
sl@0: 	TEST2(err, KErrNone);
sl@0: 	RFile64 file;
sl@0: 	err = file.Open(TheFs, KTestFile, EFileRead);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	dataptr.Zero();
sl@0: 	err = file.Read(dataptr);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	file.Close();
sl@0: 	TEST2(dataptr.Length(), KPageSize);
sl@0: 	for(TInt i=0;i<KPageSize;++i)
sl@0: 		{
sl@0: 		TEST(dataptr[i] == KChar);
sl@0: 		}
sl@0: 	TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0: 	
sl@0: 	//The file is left undeleted - to be used in ReadOomTest().
sl@0: 	delete databuf;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			PDS-SQL-UT-4208
sl@0: @SYMTestCaseDesc		RFileBuf64::Read() OOM test.
sl@0: 						The test calls RFileBuf64:Read() in an OOM
sl@0: 						simulation loop and verifies that no memory is leaked.
sl@0: 						The test also check that RFileBuf::DoSetCapacity() correctly operates in
sl@0: 						"out of memory" situation.
sl@0: @SYMTestActions			RFileBuf64::Read() OOM test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority		High
sl@0: @SYMDEF					380056
sl@0: */
sl@0: void ReadOomTest()
sl@0: 	{
sl@0: 	HBufC8* databuf = HBufC8::New(KPageSize);
sl@0: 	TEST(databuf != NULL);
sl@0: 	TPtr8 dataptr = databuf->Des();
sl@0: 	
sl@0: 	TInt err = KErrNoMemory;
sl@0: 	TInt failingAllocationNo = 0;
sl@0: 	TheTest.Printf(_L("Iteration:\r\n"));
sl@0: 	while(err == KErrNoMemory)
sl@0: 		{
sl@0: 		TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0: 
sl@0: 		MarkHandles();
sl@0: 		MarkAllocatedCells();
sl@0: 		
sl@0: 		__UHEAP_MARK;
sl@0: 		__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
sl@0: 
sl@0: 		const TInt KDefaultBufCapacity = 1024;
sl@0: 		RFileBuf64 fbuf(KDefaultBufCapacity);
sl@0: 		err = fbuf.Open(TheFs, KTestFile, EFileRead);
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = fbuf.Read(0LL, dataptr);
sl@0: 			}
sl@0: 		fbuf.Close();
sl@0: 		
sl@0: 		__UHEAP_RESET;
sl@0: 		__UHEAP_MARKEND;
sl@0: 
sl@0: 		CheckAllocatedCells();
sl@0: 		CheckHandles();
sl@0: 		}
sl@0: 	TEST2(err, KErrNone);
sl@0: 	RFile64 file;
sl@0: 	err = file.Open(TheFs, KTestFile, EFileRead);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	dataptr.Zero();
sl@0: 	err = file.Read(dataptr);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	file.Close();
sl@0: 	TEST2(dataptr.Length(), KPageSize);
sl@0: 	for(TInt i=0;i<KPageSize;++i)
sl@0: 		{
sl@0: 		TEST(dataptr[i] == KChar);
sl@0: 		}
sl@0: 	TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0: 	
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	delete databuf;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4212
sl@0: @SYMTestCaseDesc        RFileBuf64::Write() test.
sl@0:                         The test performs file write operations using RFileBuf64 class.
sl@0:                         Teh test sumilates the write operation at the conditions:
sl@0:                         
sl@0:                         1. There are 8 pages to be writted to the file.
sl@0:                         2. Each page is 16 bytes
sl@0:                         3. The size of RFileBuf64 is 4 pages, i.e. 64 bytes.
sl@0:                         4. The order of write is not sequential.
sl@0:  
sl@0: @SYMTestActions         Write database pages.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority        High
sl@0: */
sl@0: void TestSetSizeCounter()
sl@0:     {
sl@0:     const TInt KPageSize = 16;
sl@0:     const TInt KBufSize = 4 * KPageSize;
sl@0:     RFileBuf64 fbuf(KBufSize);
sl@0:     (void)TheFs.Delete(KTestFile);
sl@0:     TInt err = fbuf.Create(TheFs, KTestFile, EFileRead | EFileWrite);
sl@0:     TEST2(err, KErrNone); 
sl@0:     const TInt KMaxPage = 8;
sl@0:     TUint8 fileData[KMaxPage][KPageSize];
sl@0:     TPtrC8 pageData[KMaxPage];
sl@0:     for(TInt i = 0;i <KMaxPage;++i)
sl@0:         {
sl@0:         Mem::Fill(fileData[i], KPageSize, TChar('a' + i));
sl@0:         const TUint8* p = fileData[i]; 
sl@0:         pageData[i].Set(p, KPageSize);
sl@0:         }
sl@0:     //
sl@0:     fbuf.ProfilerReset();
sl@0:     //Write the first 4 pages
sl@0:     for (TInt ii = 0; ii < 4; ii++)
sl@0:         {
sl@0:         err = fbuf.Write(ii * KPageSize, pageData[ii]);
sl@0:         TEST2(err, KErrNone);
sl@0:         }
sl@0:     //Write page #2
sl@0:     err = fbuf.Write(2 * KPageSize, pageData[2]);
sl@0:     TEST2(err, KErrNone);
sl@0:     //
sl@0:     TEST2(fbuf.iFileWriteCount, 0);
sl@0:     TEST2(fbuf.iFileSetSizeCount, 0);
sl@0:     //Write pages 5, 4, 6, 7
sl@0:     err = fbuf.Write(5 * KPageSize, pageData[5]);
sl@0:     TEST2(err, KErrNone);
sl@0:     //
sl@0:     TEST2(fbuf.iFileWriteCount, 1);
sl@0:     TEST2(fbuf.iFileSetSizeCount, 0);
sl@0:     //
sl@0:     err = fbuf.Write(4 * KPageSize, pageData[4]);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = fbuf.Write(6 * KPageSize, pageData[6]);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = fbuf.Write(7 * KPageSize, pageData[7]);
sl@0:     TEST2(err, KErrNone);
sl@0:     //
sl@0:     TEST2(fbuf.iFileWriteCount, 1);
sl@0:     TEST2(fbuf.iFileSetSizeCount, 0);
sl@0:     //
sl@0:     err = fbuf.Flush();
sl@0:     TEST2(err, KErrNone);
sl@0:     //
sl@0:     TEST2(fbuf.iFileWriteCount, 2);
sl@0:     TEST2(fbuf.iFileSetSizeCount, 0);
sl@0:     //
sl@0:     fbuf.Close();
sl@0:     (void)TheFs.Delete(KTestFile);
sl@0:     }
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: 
sl@0: //Panic thread function. 
sl@0: //It will cast aData parameter to a TFunctor pointer and call it.
sl@0: //The expectation is that the called function will panic and kill the panic thread.
sl@0: TInt ThreadFunc(void* aData)
sl@0: 	{
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	TEST(tc != NULL);
sl@0: 	
sl@0: 	User::SetJustInTime(EFalse);	// disable debugger panic handling
sl@0: 	
sl@0: 	TFunctor* obj = reinterpret_cast<TFunctor*> (aData);
sl@0: 	TEST(obj != NULL);
sl@0: 	(*obj)();//call the panic function
sl@0: 	
sl@0: 	delete tc;
sl@0: 	
sl@0: 	return KErrNone;		
sl@0: 	}
sl@0: 
sl@0: //Panic test.
sl@0: //PanicTest function will create a new thread - panic thread, giving it a pointer to the function which has to
sl@0: //be executed and the expectation is that the function will panic and kill the panic thread.
sl@0: //PanicTest function will check the panic thread exit code, exit category and the panic code.
sl@0: void PanicTest(TFunctor& aFunctor, TExitType aExpectedExitType, const TDesC& aExpectedCategory, TInt aExpectedPanicCode)
sl@0: 	{
sl@0: 	RThread thread;
sl@0: 	_LIT(KThreadName,"SqlFileBufPanicThread");
sl@0: 	TEST2(thread.Create(KThreadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&aFunctor, EOwnerThread), KErrNone);
sl@0: 	
sl@0: 	TRequestStatus status;
sl@0: 	thread.Logon(status);
sl@0: 	TEST2(status.Int(), KRequestPending);
sl@0: 	thread.Resume();
sl@0: 	User::WaitForRequest(status);
sl@0: 	User::SetJustInTime(ETrue);	// enable debugger panic handling
sl@0: 
sl@0: 	TEST2(thread.ExitType(), aExpectedExitType);
sl@0: 	TEST(thread.ExitCategory() == aExpectedCategory);
sl@0: 	TEST2(thread.ExitReason(), aExpectedPanicCode);
sl@0: 	
sl@0: 	CLOSE_AND_WAIT(thread);
sl@0: 	}
sl@0: 
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////     Panic test functions    /////////////////////////////////////////////////
sl@0: ////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Panic when calling RFileBuf64::RFileBuf64() with an invalid buffer capacity value.
sl@0: class TSqlFileBuf_InvalidCapacity : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(-8192);//panic here - "-8192" - negative buffer capacity
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidCapacity TheSqlFileBuf_InvalidCapacity;
sl@0: 
sl@0: //Panic when calling RFileBuf64::Create() with an invalid file handle.
sl@0: class TSqlFileBuf_InvalidFileHandle1 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(8192);
sl@0: 		RFs fs;
sl@0: 		fbuf.Create(fs, _L("aaa.db"), EFileRead);//panic here - invalid file handle
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidFileHandle1 TheSqlFileBuf_InvalidFileHandle1;
sl@0: 
sl@0: //Panic when calling RFileBuf64::Create() with an invalid file name.
sl@0: class TSqlFileBuf_InvalidFileName1 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(8192);
sl@0: 		RFs fs;
sl@0: 		TInt err = fs.Connect();
sl@0: 		TEST2(err, KErrNone);
sl@0: 		fbuf.Create(fs, KNullDesC, EFileRead);//panic here - invalid file name
sl@0: 		fs.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidFileName1 TheSqlFileBuf_InvalidFileName1;
sl@0: 
sl@0: //Panic when calling RFileBuf64::Open() with an invalid file handle.
sl@0: class TSqlFileBuf_InvalidFileHandle2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(8192);
sl@0: 		RFs fs;
sl@0: 		fbuf.Open(fs, _L("aaa.db"), EFileRead);//panic here - invalid file handle
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidFileHandle2 TheSqlFileBuf_InvalidFileHandle2;
sl@0: 
sl@0: //Panic when calling RFileBuf64::Open() with an invalid file name.
sl@0: class TSqlFileBuf_InvalidFileName2 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(8192);
sl@0: 		RFs fs;
sl@0: 		TInt err = fs.Connect();
sl@0: 		TEST2(err, KErrNone);
sl@0: 		fbuf.Open(fs, KNullDesC, EFileRead);//panic here - invalid file name
sl@0: 		fs.Close();
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidFileName2 TheSqlFileBuf_InvalidFileName2;
sl@0: 
sl@0: //Panic when calling RFileBuf64::Temp() with an invalid file handle.
sl@0: class TSqlFileBuf_InvalidFileHandle3 : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(8192);
sl@0: 		RFs fs;
sl@0: 		TFileName fname;
sl@0: 		fbuf.Temp(fs, _L("c:\\test"), fname, EFileRead);//panic here - invalid file handle
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidFileHandle3 TheSqlFileBuf_InvalidFileHandle3;
sl@0: 
sl@0: //Panic when calling RFileBuf64::AdoptFromClient() with an invalid message handle.
sl@0: class TSqlFileBuf_InvalidMessageHandle : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(8192);
sl@0: 		RMessage2 msg;
sl@0: 		fbuf.AdoptFromClient(msg, 0, 1);//panic here - invalid message handle
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidMessageHandle TheSqlFileBuf_InvalidMessageHandle;
sl@0: 
sl@0: //Panic when calling RFileBuf64::Read() with an invalid file position.
sl@0: class TSqlFileBuf_InvalidReadPos : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(8192);
sl@0: 		TBuf8<50> buf;
sl@0: 		fbuf.Read(-1024, buf);//panic here - invalid file position
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidReadPos TheSqlFileBuf_InvalidReadPos;
sl@0: 
sl@0: //Panic when calling RFileBuf64::Write() with an invalid file position.
sl@0: class TSqlFileBuf_InvalidWritePos : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(8192);
sl@0: 		TBuf8<50> buf;
sl@0: 		fbuf.Write(-1024, buf);//panic here - invalid file position
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidWritePos TheSqlFileBuf_InvalidWritePos;
sl@0: 
sl@0: //Panic when calling RFileBuf64::SetSize() with an invalid file size.
sl@0: class TSqlFileBuf_InvalidSize : public TFunctor
sl@0: 	{
sl@0: private:		
sl@0: 	virtual void operator()()
sl@0: 		{
sl@0: 		RFileBuf64 fbuf(8192);
sl@0: 		TBuf8<50> buf;
sl@0: 		fbuf.SetSize(-1024);//panic here - invalid file size
sl@0: 		}
sl@0: 	};
sl@0: static TSqlFileBuf_InvalidSize TheSqlFileBuf_InvalidSize;
sl@0: 
sl@0: #endif //_DEBUG
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-UT-4236
sl@0: @SYMTestCaseDesc        RFileBuf64 panic test.
sl@0: 						The test runs a thread. The thread will create a RFileBuf64 object
sl@0: 						and put the object in a situation where the file buffer cannot perform
sl@0: 						its duties anymore and will raise a panic. The test verifies that the file
sl@0: 						buffer implementation properly detects anomalities such as bad parameters,
sl@0: 						null handles, etc... 
sl@0: @SYMTestActions         RFileBuf64 panic test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMTestPriority        High
sl@0: */
sl@0: void FileBufPanicTest()
sl@0: 	{
sl@0: #ifdef _DEBUG
sl@0: 	_LIT(KPanicCategory, "FBuf64");
sl@0: 	PanicTest(TheSqlFileBuf_InvalidCapacity, EExitPanic, KPanicCategory, 1);
sl@0: 	PanicTest(TheSqlFileBuf_InvalidFileHandle1, EExitPanic, KPanicCategory, 7);
sl@0: 	PanicTest(TheSqlFileBuf_InvalidFileName1, EExitPanic, KPanicCategory, 10);
sl@0: 	PanicTest(TheSqlFileBuf_InvalidFileHandle2, EExitPanic, KPanicCategory, 7);
sl@0: 	PanicTest(TheSqlFileBuf_InvalidFileName2, EExitPanic, KPanicCategory, 10);
sl@0: 	PanicTest(TheSqlFileBuf_InvalidFileHandle3, EExitPanic, KPanicCategory, 7);
sl@0: 	PanicTest(TheSqlFileBuf_InvalidMessageHandle, EExitPanic, KPanicCategory, 8);
sl@0: 	PanicTest(TheSqlFileBuf_InvalidReadPos, EExitPanic, KPanicCategory, 4);
sl@0: 	PanicTest(TheSqlFileBuf_InvalidWritePos, EExitPanic, KPanicCategory, 4);
sl@0: 	PanicTest(TheSqlFileBuf_InvalidSize, EExitPanic, KPanicCategory, 5);
sl@0: #else //_DEBUG
sl@0: 	TheTest.Printf(_L("This test can be run in _DEBUG mode only!"));
sl@0: #endif//_DEBUG
sl@0: 	}
sl@0: 
sl@0: void DoTests()
sl@0: 	{
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:PDS-SQL-UT-4132 RFileBuf64 write test 1"));
sl@0: 	WriteTest1();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4133 RFileBuf64 write test 2"));
sl@0: 	WriteTest2();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4134 RFileBuf64 write test 3"));
sl@0: 	WriteTest3();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4135 RFileBuf64 write test 4"));
sl@0: 	WriteTest4();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4136 RFileBuf64 write test 5"));
sl@0: 	WriteTest5();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4137 RFileBuf64 write test 6"));
sl@0: 	WriteTest6();
sl@0: 	TheTest.Next( _L("RFileBuf64 read test - preparation"));
sl@0: 	PrepareReadTest();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4138 RFileBuf64 read test 1"));
sl@0: 	ReadTest1();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4139 RFileBuf64 read test 2"));
sl@0: 	ReadTest2();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4140 RFileBuf64 read test 3"));
sl@0: 	ReadTest3();
sl@0: 
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4141 RFileBuf64::SetReadAheadSize() test"));
sl@0: 	SetReadAheadSizeTest();
sl@0: 	
sl@0: 	(void)TheFs.Delete(KTestFile);
sl@0: 	
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4142 RFileBuf64::Create() OOM test"));
sl@0: 	OomTest(EOomCreateTest);
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4142 RFileBuf64::Open() OOM test"));
sl@0: 	OomTest(EOomOpenTest);
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4142 RFileBuf64::Temp() OOM test"));
sl@0: 	OomTest(EOomTempTest);
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4207 RFileBuf64::Write() OOM test"));
sl@0: 	WriteOomTest();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4208 RFileBuf64::Read() OOM test"));
sl@0: 	ReadOomTest();
sl@0: 	
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4195 RFileBuf64::Create() file I/O error simulation test"));
sl@0: 	CreateFileIoErrTest();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4196 RFileBuf64::Open() file I/O error simulation test"));
sl@0: 	OpenFileIoErrTest();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4197 RFileBuf64::Temp() file I/O error simulation test"));
sl@0: 	OpenFileIoErrTest();
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-CT-4212 RFileBuf64::Write() test"));
sl@0: 	TestSetSizeCounter();
sl@0: 
sl@0: 	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4236 RFileBuf64 panic test"));
sl@0: 	FileBufPanicTest();
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 	
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	TheTest(tc != NULL);
sl@0: 	
sl@0: 	__UHEAP_MARK;
sl@0: 	
sl@0: 	TestEnvInit();
sl@0: 	DeleteTestFiles();
sl@0: 	DoTests();
sl@0: 	TestEnvDestroy();
sl@0: 
sl@0: 	__UHEAP_MARKEND;
sl@0: 	
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 	
sl@0: 	delete tc;
sl@0: 
sl@0: 	User::Heap().Check();
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 	
sl@0: #else//_SQLPROFILER	
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 	
sl@0:  	TheTest.Start(_L("This test works only if the test is built with _SQLPROFILER macro defined!"));
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 	
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 	
sl@0: #endif//_SQLPROFILER