Symaptic: os/persistentdata/persistentstorage/sql/TEST/t_sqlfilebuf64.cpp@bde4ae8d615e (annotated)

sl@0	1	// Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0	2	// All rights reserved.
sl@0	3	// This component and the accompanying materials are made available
sl@0	4	// under the terms of "Eclipse Public License v1.0"
sl@0	5	// which accompanies this distribution, and is available
sl@0	6	// at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0	7	//
sl@0	8	// Initial Contributors:
sl@0	9	// Nokia Corporation - initial contribution.
sl@0	10	//
sl@0	11	// Contributors:
sl@0	12	//
sl@0	13	// Description:
sl@0	14	//
sl@0	15	#include <e32test.h>
sl@0	16
sl@0	17	#ifdef _SQLPROFILER
sl@0	18
sl@0	19	#include <bautils.h>
sl@0	20	#include "FileBuf64.h"
sl@0	21
sl@0	22	///////////////////////////////////////////////////////////////////////////////////////
sl@0	23
sl@0	24	TBool TheOsCallTimeDetailedProfileEnabled = ETrue;//Needed because the RFileBuf64 source is included directly into this test
sl@0	25	//nd the sql profiler is enabled (_SQLPROFILER is defined in the MMP file)
sl@0	26
sl@0	27	static RTest TheTest(_L("t_sqlfilebuf64 test"));
sl@0	28	static RFs TheFs;
sl@0	29
sl@0	30	_LIT(KTestDir, "c:\\test\\");
sl@0	31	_LIT(KTestFile, "c:\\test\\t_sqlfilebuf64.bin");
sl@0	32	_LIT(KTestFile2, "\\test\\t_sqlfilebuf64_2.bin");
sl@0	33	_LIT(KTestFile3, "c:\\test\\t_sqlfilebuf64_3.bin");
sl@0	34
sl@0	35	static TBuf8<1024> TheBuf;
sl@0	36	static TFileName TheDbName;
sl@0	37
sl@0	38	static TInt TheProcessHandleCount = 0;
sl@0	39	static TInt TheThreadHandleCount = 0;
sl@0	40	static TInt TheAllocatedCellsCount = 0;
sl@0	41
sl@0	42	#ifdef _DEBUG
sl@0	43	static const TInt KBurstRate = 100;
sl@0	44	#endif
sl@0	45
sl@0	46	enum TOomTestType
sl@0	47	{
sl@0	48	EOomCreateTest,
sl@0	49	EOomOpenTest,
sl@0	50	EOomTempTest
sl@0	51	};
sl@0	52
sl@0	53	//Used in read/write OOM tests
sl@0	54	const TUint8 KChar = 'A';
sl@0	55	const TInt KPageSize = 32768;
sl@0	56
sl@0	57	///////////////////////////////////////////////////////////////////////////////////////
sl@0	58
sl@0	59	void DeleteTestFiles()
sl@0	60	{
sl@0	61	if(TheDbName.Length() > 0)
sl@0	62	{
sl@0	63	(void)TheFs.Delete(TheDbName);
sl@0	64	}
sl@0	65	(void)TheFs.Delete(KTestFile3);
sl@0	66	(void)TheFs.Delete(KTestFile);
sl@0	67	}
sl@0	68
sl@0	69	void TestEnvDestroy()
sl@0	70	{
sl@0	71	DeleteTestFiles();
sl@0	72	TheFs.Close();
sl@0	73	}
sl@0	74
sl@0	75	///////////////////////////////////////////////////////////////////////////////////////
sl@0	76	///////////////////////////////////////////////////////////////////////////////////////
sl@0	77	//Test macros and functions
sl@0	78	void Check1(TInt aValue, TInt aLine)
sl@0	79	{
sl@0	80	if(!aValue)
sl@0	81	{
sl@0	82	TestEnvDestroy();
sl@0	83	RDebug::Print(_L("*** Line %d\r\n"), aLine);
sl@0	84	TheTest(EFalse, aLine);
sl@0	85	}
sl@0	86	}
sl@0	87	void Check2(TInt aValue, TInt aExpected, TInt aLine)
sl@0	88	{
sl@0	89	if(aValue != aExpected)
sl@0	90	{
sl@0	91	TestEnvDestroy();
sl@0	92	RDebug::Print(_L("*** Line %d, Expected result: %d, got: %d\r\n"), aLine, aExpected, aValue);
sl@0	93	TheTest(EFalse, aLine);
sl@0	94	}
sl@0	95	}
sl@0	96	#define TEST(arg) ::Check1((arg), __LINE__)
sl@0	97	#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
sl@0	98
sl@0	99	///////////////////////////////////////////////////////////////////////////////////////
sl@0	100
sl@0	101	void TestEnvInit()
sl@0	102	{
sl@0	103	TInt err = TheFs.Connect();
sl@0	104	TEST2(err, KErrNone);
sl@0	105
sl@0	106	err = TheFs.MkDir(KTestDir);
sl@0	107	TEST(err == KErrNone \|\| err == KErrAlreadyExists);
sl@0	108	}
sl@0	109
sl@0	110	///////////////////////////////////////////////////////////////////////////////////////
sl@0	111
sl@0	112	static void MarkHandles()
sl@0	113	{
sl@0	114	RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);
sl@0	115	}
sl@0	116
sl@0	117	static void MarkAllocatedCells()
sl@0	118	{
sl@0	119	TheAllocatedCellsCount = User::CountAllocCells();
sl@0	120	}
sl@0	121
sl@0	122	static void CheckAllocatedCells()
sl@0	123	{
sl@0	124	TInt allocatedCellsCount = User::CountAllocCells();
sl@0	125	TEST2(allocatedCellsCount, TheAllocatedCellsCount);
sl@0	126	}
sl@0	127
sl@0	128	static void CheckHandles()
sl@0	129	{
sl@0	130	TInt endProcessHandleCount;
sl@0	131	TInt endThreadHandleCount;
sl@0	132
sl@0	133	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
sl@0	134
sl@0	135	TEST2(TheProcessHandleCount, endProcessHandleCount);
sl@0	136	TEST2(TheThreadHandleCount, endThreadHandleCount);
sl@0	137	}
sl@0	138
sl@0	139	static void VerifyFileContent(const TDesC8& aPattern)
sl@0	140	{
sl@0	141	TheBuf.Zero();
sl@0	142
sl@0	143	RFile64 file;
sl@0	144	TInt err = file.Open(TheFs, KTestFile, EFileShareReadersOrWriters);
sl@0	145	TEST2(err, KErrNone);
sl@0	146
sl@0	147	TInt64 fsize;
sl@0	148	err = file.Size(fsize);
sl@0	149	TEST2(err, KErrNone);
sl@0	150	TEST2((TInt)fsize, aPattern.Length());
sl@0	151
sl@0	152	err = file.Read(TheBuf, aPattern.Length());
sl@0	153	TEST2(err, KErrNone);
sl@0	154
sl@0	155	file.Close();
sl@0	156
sl@0	157	err = TheBuf.Compare(aPattern);
sl@0	158	TEST2(err, 0);
sl@0	159	}
sl@0	160
sl@0	161	static void VerifyFileContent(const TDesC8& aPattern, TInt64 aFilePos)
sl@0	162	{
sl@0	163	__ASSERT_DEBUG(aFilePos >= 0, User::Invariant());
sl@0	164
sl@0	165	TheBuf.Zero();
sl@0	166
sl@0	167	RFile64 file;
sl@0	168	TInt err = file.Open(TheFs, KTestFile, EFileShareReadersOrWriters);
sl@0	169	TEST2(err, KErrNone);
sl@0	170
sl@0	171	err = file.Read(aFilePos, TheBuf, aPattern.Length());
sl@0	172	TEST2(err, KErrNone);
sl@0	173
sl@0	174	file.Close();
sl@0	175
sl@0	176	err = TheBuf.Compare(aPattern);
sl@0	177	TEST2(err, 0);
sl@0	178	}
sl@0	179
sl@0	180	/**
sl@0	181	@SYMTestCaseID PDS-SQL-UT-4132
sl@0	182	@SYMTestCaseDesc RFileBuf64 write test 1.
sl@0	183	The test performs file write operations using RFileBuf64 class.
sl@0	184	The write positions are inside the buffer or right at the end of the buffer.
sl@0	185	The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0	186	@SYMTestActions RFileBuf64 write test 1.
sl@0	187	@SYMTestExpectedResults Test must not fail
sl@0	188	@SYMTestPriority High
sl@0	189	@SYMREQ REQ12106
sl@0	190	REQ12109
sl@0	191	*/
sl@0	192	void WriteTest1()
sl@0	193	{
sl@0	194	RFileBuf64 fbuf(1024);
sl@0	195	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0	196	TEST2(err, KErrNone);
sl@0	197	fbuf.ProfilerReset();
sl@0	198
sl@0	199	//Zero write request
sl@0	200	err = fbuf.Write(0, _L8(""));
sl@0	201	TEST2(err, KErrNone);
sl@0	202	TEST2(fbuf.iFileWriteCount, 0);
sl@0	203	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	204	TEST2(fbuf.iFileSizeCount, 0);
sl@0	205
sl@0	206	//First write operation. After the operation the file buffer must countain 10 bytes.
sl@0	207	err = fbuf.Write(0, _L8("A123456789"));
sl@0	208	TEST2(err, KErrNone);
sl@0	209	TEST2(fbuf.iFileWriteCount, 0);
sl@0	210	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	211	TEST2(fbuf.iFileSizeCount, 1);
sl@0	212
sl@0	213	//Second write operation. The offset is at the middle of the buffer. Data length: 10;
sl@0	214	err = fbuf.Write(5, _L8("ZZZZZEEEEE"));
sl@0	215	TEST2(err, KErrNone);
sl@0	216	TEST2(fbuf.iFileWriteCount, 0);
sl@0	217	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	218
sl@0	219	//Third write operation. The offset is at the end of the buffer. Data length: 5;
sl@0	220	err = fbuf.Write(15, _L8("CCCCC"));
sl@0	221	TEST2(err, KErrNone);
sl@0	222	TEST2(fbuf.iFileWriteCount, 0);
sl@0	223	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	224
sl@0	225	err = fbuf.Flush();
sl@0	226	TEST2(err, KErrNone);
sl@0	227	TEST2(fbuf.iFileWriteCount, 1);
sl@0	228	TEST2(fbuf.iFileFlushCount, 1);
sl@0	229	TEST2(fbuf.iFileWriteAmount, 20);
sl@0	230	TEST2(fbuf.iFileSizeCount, 1);
sl@0	231
sl@0	232	fbuf.Close();
sl@0	233
sl@0	234	VerifyFileContent(_L8("A1234ZZZZZEEEEECCCCC"));
sl@0	235
sl@0	236	(void)TheFs.Delete(KTestFile);
sl@0	237	}
sl@0	238
sl@0	239	/**
sl@0	240	@SYMTestCaseID PDS-SQL-UT-4133
sl@0	241	@SYMTestCaseDesc RFileBuf64 write test 2.
sl@0	242	The test performs file write operations using RFileBuf64 class.
sl@0	243	The write positions are beyound the end of the file but within the buffer capacity.
sl@0	244	The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0	245	@SYMTestActions RFileBuf64 write test 2.
sl@0	246	@SYMTestExpectedResults Test must not fail
sl@0	247	@SYMTestPriority High
sl@0	248	@SYMREQ REQ12106
sl@0	249	REQ12109
sl@0	250	*/
sl@0	251	void WriteTest2()
sl@0	252	{
sl@0	253	RFileBuf64 fbuf(1024);
sl@0	254	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0	255	TEST2(err, KErrNone);
sl@0	256	fbuf.ProfilerReset();
sl@0	257
sl@0	258	//First write operation. After the operation the file buffer must countain 10 bytes.
sl@0	259	err = fbuf.Write(0, _L8("A123456789"));
sl@0	260	TEST2(err, KErrNone);
sl@0	261	TEST2(fbuf.iFileWriteCount, 0);
sl@0	262	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	263	TEST2(fbuf.iFileSizeCount, 1);
sl@0	264
sl@0	265	//Second write operation. After the operation the file buffer must countain 10 + 10 zeros + 10 bytes.
sl@0	266	err = fbuf.Write(20, _L8("FFGGHHJJKK"));
sl@0	267	TEST2(err, KErrNone);
sl@0	268	TEST2(fbuf.iFileWriteCount, 0);
sl@0	269	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	270	TEST2(fbuf.iFileSizeCount, 1);
sl@0	271
sl@0	272	err = fbuf.Flush();
sl@0	273	TEST2(err, KErrNone);
sl@0	274	TEST2(fbuf.iFileWriteCount, 1);
sl@0	275	TEST2(fbuf.iFileFlushCount, 1);
sl@0	276	TEST2(fbuf.iFileWriteAmount, 30);
sl@0	277	TEST2(fbuf.iFileSizeCount, 1);
sl@0	278
sl@0	279	fbuf.Close();
sl@0	280
sl@0	281	TBuf8<30> pattern;
sl@0	282	pattern.Append(_L8("A123456789"));
sl@0	283	pattern.AppendFill(TChar(0), 10);
sl@0	284	pattern.Append(_L8("FFGGHHJJKK"));
sl@0	285	VerifyFileContent(pattern);
sl@0	286
sl@0	287	(void)TheFs.Delete(KTestFile);
sl@0	288	}
sl@0	289
sl@0	290	/**
sl@0	291	@SYMTestCaseID PDS-SQL-UT-4134
sl@0	292	@SYMTestCaseDesc RFileBuf64 write test 3.
sl@0	293	The test performs file write operations using RFileBuf64 class.
sl@0	294	The write position is before the start of the buffer but there is room for move.
sl@0	295	The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0	296	@SYMTestActions RFileBuf64 write test 3.
sl@0	297	@SYMTestExpectedResults Test must not fail
sl@0	298	@SYMTestPriority High
sl@0	299	@SYMREQ REQ12106
sl@0	300	REQ12109
sl@0	301	*/
sl@0	302	void WriteTest3()
sl@0	303	{
sl@0	304	//Iteration 1: The file length is 0, the first operation is "write beyond the end"
sl@0	305	//Iteration 2: The file length is 30, the first write operation is within the file.
sl@0	306	for(TInt i=0;i<2;++i)
sl@0	307	{
sl@0	308	RFileBuf64 fbuf(1024);
sl@0	309	TInt err = i == 0 ? fbuf.Create(TheFs, KTestFile, EFileWrite) : fbuf.Open(TheFs, KTestFile, EFileWrite);
sl@0	310	TEST2(err, KErrNone);
sl@0	311	fbuf.ProfilerReset();
sl@0	312
sl@0	313	//First write operation. The offset is not 0. Data length: 10;
sl@0	314	err = fbuf.Write(20, _L8("A123456789"));
sl@0	315	TEST2(err, KErrNone);
sl@0	316	TEST2(fbuf.iFileWriteCount, 0);
sl@0	317	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	318	TEST2(fbuf.iFileSizeCount, 1);
sl@0	319
sl@0	320	//Second write operation. The offset is 0. Data length: 20;
sl@0	321	err = fbuf.Write(0, _L8("AASSDDFFRR**********"));
sl@0	322	TEST2(err, KErrNone);
sl@0	323	TEST2(fbuf.iFileWriteCount, 0);
sl@0	324	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	325	TEST2(fbuf.iFileSizeCount, 1);
sl@0	326
sl@0	327	err = fbuf.Flush();
sl@0	328	TEST2(err, KErrNone);
sl@0	329	TEST2(fbuf.iFileWriteCount, 1);
sl@0	330	TEST2(fbuf.iFileFlushCount, 1);
sl@0	331	TEST2(fbuf.iFileWriteAmount, 30);
sl@0	332	TEST2(fbuf.iFileSizeCount, 1);
sl@0	333
sl@0	334	fbuf.Close();
sl@0	335
sl@0	336	VerifyFileContent(_L8("AASSDDFFRR**********A123456789"));
sl@0	337	}
sl@0	338	(void)TheFs.Delete(KTestFile);
sl@0	339	}
sl@0	340
sl@0	341	/**
sl@0	342	@SYMTestCaseID PDS-SQL-UT-4135
sl@0	343	@SYMTestCaseDesc RFileBuf64 write test 4.
sl@0	344	The test performs file write operations using RFileBuf64 class and verifies that
sl@0	345	that the pending write data will be stored in the file when the buffer is closed.
sl@0	346	The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0	347	@SYMTestActions RFileBuf64 write test 4.
sl@0	348	@SYMTestExpectedResults Test must not fail
sl@0	349	@SYMTestPriority High
sl@0	350	@SYMREQ REQ12106
sl@0	351	REQ12109
sl@0	352	*/
sl@0	353	void WriteTest4()
sl@0	354	{
sl@0	355	RFileBuf64 fbuf(1024);
sl@0	356	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0	357	TEST2(err, KErrNone);
sl@0	358	fbuf.ProfilerReset();
sl@0	359
sl@0	360	// Data length: 10;
sl@0	361	err = fbuf.Write(0, _L8("A123456789"));
sl@0	362	TEST2(err, KErrNone);
sl@0	363	TEST2(fbuf.iFileWriteCount, 0);
sl@0	364	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	365	TEST2(fbuf.iFileSizeCount, 1);
sl@0	366
sl@0	367	// Data length: 0;
sl@0	368	err = fbuf.Write(10, _L8(""));
sl@0	369	TEST2(err, KErrNone);
sl@0	370	TEST2(fbuf.iFileWriteCount, 0);
sl@0	371	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	372	TEST2(fbuf.iFileSizeCount, 1);
sl@0	373
sl@0	374	fbuf.Close();
sl@0	375
sl@0	376	VerifyFileContent(_L8("A123456789"));
sl@0	377
sl@0	378	(void)TheFs.Delete(KTestFile);
sl@0	379	}
sl@0	380
sl@0	381	/**
sl@0	382	@SYMTestCaseID PDS-SQL-UT-4136
sl@0	383	@SYMTestCaseDesc RFileBuf64 write test 5.
sl@0	384	The test performs file write operations using RFileBuf64 class.
sl@0	385	The data is written before the start of the file buffer and is too big to fit in the buffer.
sl@0	386	The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0	387	@SYMTestActions RFileBuf64 write test 5.
sl@0	388	@SYMTestExpectedResults Test must not fail
sl@0	389	@SYMTestPriority High
sl@0	390	@SYMREQ REQ12106
sl@0	391	REQ12109
sl@0	392	*/
sl@0	393	void WriteTest5()
sl@0	394	{
sl@0	395	RFileBuf64 fbuf(20);
sl@0	396	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0	397	TEST2(err, KErrNone);
sl@0	398	fbuf.ProfilerReset();
sl@0	399
sl@0	400	//First write operation. The offset is not 0. Data length: 10;
sl@0	401	err = fbuf.Write(10, _L8("A123456789"));
sl@0	402	TEST2(err, KErrNone);
sl@0	403	TEST2(fbuf.iFileWriteCount, 0);
sl@0	404	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	405	TEST2(fbuf.iFileSizeCount, 1);
sl@0	406
sl@0	407	//Second write operation. The offset is 0. Data length: 12, i.e. within the buffer - should have no write to the disk.
sl@0	408	err = fbuf.Write(0, _L8("ZZXXCCVVBBNN"));
sl@0	409	TEST2(err, KErrNone);
sl@0	410	TEST2(fbuf.iFileWriteCount, 0);
sl@0	411	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	412	TEST2(fbuf.iFileSizeCount, 1);
sl@0	413
sl@0	414	//Third write operation. The offet is 18. Data length: 5. The buffer should be written out to the file
sl@0	415	// after "ab" is appended to the buffer. The new buffe after being emptied should have data "cde".
sl@0	416	err = fbuf.Write(18, _L8("abcde"));
sl@0	417	TEST2(err, KErrNone);
sl@0	418	TEST2(fbuf.iFileWriteCount, 1);
sl@0	419	TEST2(fbuf.iFileWriteAmount, 20);
sl@0	420	TEST2(fbuf.iFileSizeCount, 1);
sl@0	421
sl@0	422	err = fbuf.Flush();
sl@0	423	TEST2(err, KErrNone);
sl@0	424	TEST2(fbuf.iFileWriteCount, 2);
sl@0	425	TEST2(fbuf.iFileFlushCount, 1);
sl@0	426	TEST2(fbuf.iFileWriteAmount, 23);
sl@0	427	TEST2(fbuf.iFileSizeCount, 1);
sl@0	428
sl@0	429	fbuf.Close();
sl@0	430
sl@0	431	VerifyFileContent(_L8("ZZXXCCVVBBNN234567abcde"));
sl@0	432
sl@0	433	(void)TheFs.Delete(KTestFile);
sl@0	434	}
sl@0	435
sl@0	436	/**
sl@0	437	@SYMTestCaseID PDS-SQL-UT-4137
sl@0	438	@SYMTestCaseDesc RFileBuf64 write test 6.
sl@0	439	The test performs file write operations using RFileBuf64 class.
sl@0	440	The data is written before the start of the file buffer and is too big to fit in the buffer.
sl@0	441	The purpose of the test: to verify the logic of RFileBuf64::Write().
sl@0	442	@SYMTestActions RFileBuf64 write test 6.
sl@0	443	@SYMTestExpectedResults Test must not fail
sl@0	444	@SYMTestPriority High
sl@0	445	@SYMREQ REQ12106
sl@0	446	REQ12109
sl@0	447	*/
sl@0	448	void WriteTest6()
sl@0	449	{
sl@0	450	RFileBuf64 fbuf(20);
sl@0	451	TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
sl@0	452	TEST2(err, KErrNone);
sl@0	453
sl@0	454	err = fbuf.Write(0, _L8("A123456789B123456789C123456789"));
sl@0	455	TEST2(err, KErrNone);
sl@0	456	err = fbuf.Flush();
sl@0	457	TEST2(err, KErrNone);
sl@0	458	fbuf.Close();
sl@0	459	VerifyFileContent(_L8("A123456789B123456789C123456789"));
sl@0	460
sl@0	461	err = fbuf.Open(TheFs, KTestFile, EFileWrite);
sl@0	462	TEST2(err, KErrNone);
sl@0	463	fbuf.ProfilerReset();
sl@0	464
sl@0	465	//First write operation. The offset is not 0. Data length: 10;
sl@0	466	err = fbuf.Write(15, _L8("OOOOOOOOOO"));
sl@0	467	TEST2(err, KErrNone);
sl@0	468	TEST2(fbuf.iFileWriteCount, 0);
sl@0	469	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	470	TEST2(fbuf.iFileSizeCount, 1);
sl@0	471
sl@0	472	//Second write operation. The offset is 0. Data length: 15;
sl@0	473	err = fbuf.Write(0, _L8("TTTTTTTTTTTTTTT"));
sl@0	474	TEST2(err, KErrNone);
sl@0	475	TEST2(fbuf.iFileWriteCount, 1);
sl@0	476	TEST2(fbuf.iFileWriteAmount, 10);
sl@0	477	TEST2(fbuf.iFileSizeCount, 1);
sl@0	478
sl@0	479	err = fbuf.Flush();
sl@0	480	TEST2(err, KErrNone);
sl@0	481	TEST2(fbuf.iFileWriteCount, 2);
sl@0	482	TEST2(fbuf.iFileFlushCount, 1);
sl@0	483	TEST2(fbuf.iFileWriteAmount, 15 + 10);
sl@0	484	TEST2(fbuf.iFileSizeCount, 1);
sl@0	485
sl@0	486	fbuf.Close();
sl@0	487
sl@0	488	VerifyFileContent(_L8("TTTTTTTTTTTTTTTOOOOOOOOOO56789"));
sl@0	489
sl@0	490	(void)TheFs.Delete(KTestFile);
sl@0	491	}
sl@0	492
sl@0	493	void PrepareReadTest()
sl@0	494	{
sl@0	495	RFile64 file;
sl@0	496	TInt err = file.Create(TheFs, KTestFile, EFileWrite);
sl@0	497	TEST2(err, KErrNone);
sl@0	498	err = file.Write(_L8("A123456789ZZZZZZZZZZB-B-B-B-B-YYYYY*"));
sl@0	499	TEST2(err, KErrNone);
sl@0	500	err = file.Flush();
sl@0	501	TEST2(err, KErrNone);
sl@0	502	file.Close();
sl@0	503	}
sl@0	504
sl@0	505	/**
sl@0	506	@SYMTestCaseID PDS-SQL-UT-4138
sl@0	507	@SYMTestCaseDesc RFileBuf64 read test 1.
sl@0	508	The test performs file read operations using RFileBuf64 class.
sl@0	509	Tested "read" operations:
sl@0	510	- Zero max length request;
sl@0	511	- Too big read request;
sl@0	512	- Read beyond the end of the file;
sl@0	513	The purpose of the test: to verify the logic of RFileBuf64::Read().
sl@0	514	@SYMTestActions RFileBuf64 read test 1.
sl@0	515	@SYMTestExpectedResults Test must not fail
sl@0	516	@SYMTestPriority High
sl@0	517	@SYMREQ REQ12106
sl@0	518	REQ12109
sl@0	519	*/
sl@0	520	void ReadTest1()
sl@0	521	{
sl@0	522	const TInt KBufMaxSize = 20;// This is half the file size
sl@0	523	RFileBuf64 fbuf(KBufMaxSize);
sl@0	524	TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite \| EFileRead \| EFileShareReadersOrWriters);
sl@0	525	TEST2(err, KErrNone);
sl@0	526	fbuf.ProfilerReset();
sl@0	527
sl@0	528	//Zero max length request
sl@0	529	TUint8 buf1[1];
sl@0	530	TPtr8 ptr1(buf1, 0);
sl@0	531	err = fbuf.Read(0, ptr1);
sl@0	532	TEST2(err, KErrNone);
sl@0	533	TEST2(fbuf.iFileReadCount, 0);
sl@0	534	TEST2(fbuf.iFileReadAmount, 0);
sl@0	535	TEST2(fbuf.iFileSizeCount, 0);
sl@0	536
sl@0	537	//Too big request
sl@0	538	TBuf8<KBufMaxSize * 2> buf2;
sl@0	539	err = fbuf.Read(0, buf2);
sl@0	540	TEST2(err, KErrNone);
sl@0	541	TEST2(fbuf.iFileReadCount, 1);
sl@0	542	TEST2(fbuf.iFileReadAmount, (KBufMaxSize * 2));
sl@0	543	TEST2(fbuf.iFileSizeCount, 1);
sl@0	544	VerifyFileContent(buf2);
sl@0	545
sl@0	546	//Read beyond the end of the file
sl@0	547	err = fbuf.Read(2000, buf2);
sl@0	548	TEST2(err, KErrNone);
sl@0	549	TEST2(buf2.Length(), 0);
sl@0	550
sl@0	551	//Write "5678" in the buffer, pos [4..8)
sl@0	552	err = fbuf.Write(4, _L8("5678"));
sl@0	553	TEST2(err, KErrNone);
sl@0	554
sl@0	555	//Too big request. There are pending data in the buffer.
sl@0	556	TBuf8<KBufMaxSize + 2> buf3;
sl@0	557	err = fbuf.Read(1, buf3);
sl@0	558	TEST2(err, KErrNone);
sl@0	559	VerifyFileContent(buf3, 1);
sl@0	560
sl@0	561	//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	562	TBuf8<5> buf4;
sl@0	563	err = fbuf.Read(30, buf4);
sl@0	564	TEST2(err, KErrNone);
sl@0	565	VerifyFileContent(buf4, 30);
sl@0	566	err = fbuf.Read(35, buf4);
sl@0	567	TEST2(err, KErrNone);
sl@0	568	VerifyFileContent(buf4, 35);
sl@0	569
sl@0	570	//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	571	err = fbuf.Read(10, buf3);
sl@0	572	TEST2(err, KErrNone);
sl@0	573	VerifyFileContent(buf3, 10);
sl@0	574
sl@0	575	fbuf.Close();
sl@0	576	}
sl@0	577
sl@0	578	/**
sl@0	579	@SYMTestCaseID PDS-SQL-UT-4139
sl@0	580	@SYMTestCaseDesc RFileBuf64 read test 2.
sl@0	581	The test performs file read operations using RFileBuf64 class.
sl@0	582	Tested operations:
sl@0	583	- Non-buffered reads;
sl@0	584	- Buffered reads;
sl@0	585	The purpose of the test: to verify the logic of RFileBuf64::Read().
sl@0	586	@SYMTestActions RFileBuf64 read test 2.
sl@0	587	@SYMTestExpectedResults Test must not fail
sl@0	588	@SYMTestPriority High
sl@0	589	@SYMREQ REQ12106
sl@0	590	REQ12109
sl@0	591	*/
sl@0	592	void ReadTest2()
sl@0	593	{
sl@0	594	RFileBuf64 fbuf(1024);
sl@0	595	TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite \| EFileRead \| EFileShareReadersOrWriters);
sl@0	596	TEST2(err, KErrNone);
sl@0	597	fbuf.ProfilerReset();
sl@0	598
sl@0	599	//1. Read bytes [0..20]
sl@0	600	TBuf8<20> buf1;
sl@0	601	err = fbuf.Read(0, buf1);
sl@0	602	TEST2(err, KErrNone);
sl@0	603	TEST2(fbuf.iFileReadCount, 1);
sl@0	604	TEST2(fbuf.iFileReadAmount, 20);
sl@0	605	TEST2(fbuf.iFileSizeCount, 1);
sl@0	606	fbuf.ProfilerReset();
sl@0	607	VerifyFileContent(buf1, 0);
sl@0	608
sl@0	609	//2. Read again, bytes [10..20]. They are not buffered.
sl@0	610	TBuf8<10> buf2;
sl@0	611	err = fbuf.Read(10, buf2);
sl@0	612	TEST2(err, KErrNone);
sl@0	613	TEST2(fbuf.iFileReadCount, 1);
sl@0	614	TEST2(fbuf.iFileReadAmount, 10);
sl@0	615	TEST2(fbuf.iFileSizeCount, 0);
sl@0	616	fbuf.ProfilerReset();
sl@0	617	VerifyFileContent(buf2, 10);
sl@0	618
sl@0	619	//3. Read again, bytes [20..30]. They are not buffered. But the file buffer will be populated,
sl@0	620	// because the file read position matches the guessed file read position from step 2.
sl@0	621	err = fbuf.Read(20, buf2);
sl@0	622	TEST2(err, KErrNone);
sl@0	623	TEST2(fbuf.iFileReadCount, 1);
sl@0	624	TEST2(fbuf.iFileReadAmount, (10 * 2));
sl@0	625	TEST2(fbuf.iFileSizeCount, 0);
sl@0	626	fbuf.ProfilerReset();
sl@0	627	VerifyFileContent(buf2, 20);
sl@0	628
sl@0	629	//4. Read again, bytes [25..35]. This is a buffered read operation.
sl@0	630	err = fbuf.Read(25, buf2);
sl@0	631	TEST2(err, KErrNone);
sl@0	632	TEST2(fbuf.iFileReadCount, 0);
sl@0	633	TEST2(fbuf.iFileReadAmount, 0);
sl@0	634	TEST2(fbuf.iFileSizeCount, 0);
sl@0	635	fbuf.ProfilerReset();
sl@0	636	VerifyFileContent(buf2, 25);
sl@0	637
sl@0	638	//5. Read again, bytes [15..25]. This is a non buffered read operation.
sl@0	639	err = fbuf.Read(15, buf2);
sl@0	640	TEST2(err, KErrNone);
sl@0	641	TEST2(fbuf.iFileReadCount, 1);
sl@0	642	TEST2(fbuf.iFileReadAmount, 10);
sl@0	643	TEST2(fbuf.iFileSizeCount, 0);
sl@0	644	fbuf.ProfilerReset();
sl@0	645	VerifyFileContent(buf2, 15);
sl@0	646
sl@0	647	//6. Read again, bytes [25..35]. This is a buffered read operation. The buffer from step 3 is still there.
sl@0	648	err = fbuf.Read(25, buf2);
sl@0	649	TEST2(err, KErrNone);
sl@0	650	TEST2(fbuf.iFileReadCount, 0);
sl@0	651	TEST2(fbuf.iFileReadAmount, 0);
sl@0	652	TEST2(fbuf.iFileSizeCount, 0);
sl@0	653	fbuf.ProfilerReset();
sl@0	654	VerifyFileContent(buf2, 25);
sl@0	655
sl@0	656	//7. Read again, bytes [35..45] - beyond the end of the file.
sl@0	657	// This is a buffered read operation. The buffer from step 3 is still there.
sl@0	658	err = fbuf.Read(35, buf2);
sl@0	659	TEST2(err, KErrNone);
sl@0	660	TEST2(fbuf.iFileReadCount, 0);
sl@0	661	TEST2(fbuf.iFileReadAmount, 0);
sl@0	662	TEST2(fbuf.iFileSizeCount, 0);
sl@0	663	TEST2(buf2.Size(), 5);
sl@0	664	fbuf.ProfilerReset();
sl@0	665	VerifyFileContent(buf2, 35);
sl@0	666
sl@0	667	fbuf.Close();
sl@0	668	}
sl@0	669
sl@0	670	/**
sl@0	671	@SYMTestCaseID PDS-SQL-UT-4140
sl@0	672	@SYMTestCaseDesc RFileBuf64 read test 3.
sl@0	673	The test performs file read operations using RFileBuf64 class.
sl@0	674	Tested operations:
sl@0	675	- Non-buffered reads;
sl@0	676	- Buffered reads;
sl@0	677	- Part- buffered reads;
sl@0	678	The purpose of the test: to verify the logic of RFileBuf64::Read().
sl@0	679	@SYMTestActions RFileBuf64 read test 3.
sl@0	680	@SYMTestExpectedResults Test must not fail
sl@0	681	@SYMTestPriority High
sl@0	682	@SYMREQ REQ12106
sl@0	683	REQ12109
sl@0	684	*/
sl@0	685	void ReadTest3()
sl@0	686	{
sl@0	687	RFileBuf64 fbuf(1024);
sl@0	688	TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite \| EFileRead \| EFileShareReadersOrWriters);
sl@0	689	TEST2(err, KErrNone);
sl@0	690	fbuf.ProfilerReset();
sl@0	691
sl@0	692	//1. Read bytes [0..10]. Non buffered.
sl@0	693	TBuf8<10> buf1;
sl@0	694	err = fbuf.Read(0, buf1);
sl@0	695	TEST2(err, KErrNone);
sl@0	696	TEST2(fbuf.iFileReadCount, 1);
sl@0	697	TEST2(fbuf.iFileReadAmount, 10);
sl@0	698	TEST2(fbuf.iFileSizeCount, 1);
sl@0	699	fbuf.ProfilerReset();
sl@0	700	VerifyFileContent(buf1, 0);
sl@0	701
sl@0	702	//2. Read bytes [10..20]. Non buffered. But the file buffer is populated, bytes [10..40].
sl@0	703	err = fbuf.Read(10, buf1);
sl@0	704	TEST2(err, KErrNone);
sl@0	705	TEST2(fbuf.iFileReadCount, 1);
sl@0	706	TEST2(fbuf.iFileReadAmount, 30);
sl@0	707	TEST2(fbuf.iFileSizeCount, 0);
sl@0	708	fbuf.ProfilerReset();
sl@0	709	VerifyFileContent(buf1, 10);
sl@0	710
sl@0	711	//3. Read bytes [25..35]. Buffered. Because the previous operation [2] performed a read-ahead operation.
sl@0	712	err = fbuf.Read(25, buf1);
sl@0	713	TEST2(err, KErrNone);
sl@0	714	TEST2(fbuf.iFileReadCount, 0);
sl@0	715	TEST2(fbuf.iFileReadAmount, 0);
sl@0	716	TEST2(fbuf.iFileSizeCount, 0);
sl@0	717	fbuf.ProfilerReset();
sl@0	718	VerifyFileContent(buf1, 25);
sl@0	719
sl@0	720	//4. Write bytes [20..30]. Buffered. Read buffer is gone, the file buffer contains the [20..30] file area.
sl@0	721	err = fbuf.Write(20, _L8("IIIIIQQQQQ"));
sl@0	722	TEST2(err, KErrNone);
sl@0	723	TEST2(fbuf.iFileReadCount, 0);
sl@0	724	TEST2(fbuf.iFileReadAmount, 0);
sl@0	725	TEST2(fbuf.iFileWriteCount, 0);
sl@0	726	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	727	TEST2(fbuf.iFileSizeCount, 0);
sl@0	728	fbuf.ProfilerReset();
sl@0	729
sl@0	730	//5. Read bytes [25..35]. Part-buffered. Part of pending writes picked up. Then the buffer is flushed.
sl@0	731	err = fbuf.Read(25, buf1);
sl@0	732	TEST2(err, KErrNone);
sl@0	733	TEST2(fbuf.iFileReadCount, 1);
sl@0	734	TEST2(fbuf.iFileReadAmount, 5);
sl@0	735	TEST2(fbuf.iFileWriteCount, 1);
sl@0	736	TEST2(fbuf.iFileWriteAmount, 10);
sl@0	737	TEST2(fbuf.iFileSizeCount, 0);
sl@0	738
sl@0	739	fbuf.ProfilerReset();
sl@0	740	err = fbuf.Flush();
sl@0	741	TEST2(err, KErrNone);
sl@0	742
sl@0	743	//All cached data should have been written to the file before the Flush() call.
sl@0	744	TEST2(fbuf.iFileReadCount, 0);
sl@0	745	TEST2(fbuf.iFileReadAmount, 0);
sl@0	746	TEST2(fbuf.iFileWriteCount, 0);
sl@0	747	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	748	TEST2(fbuf.iFileSizeCount, 0);
sl@0	749	TEST2(fbuf.iFileFlushCount, 1);
sl@0	750
sl@0	751	fbuf.ProfilerReset();
sl@0	752	VerifyFileContent(buf1, 25);
sl@0	753
sl@0	754	//6. The buffer is empty after the last flush. Write bytes [0..10]. The file buffer contains the [0..10] file area.
sl@0	755	err = fbuf.Write(0, _L8("PPOOIIUUYY"));
sl@0	756	TEST2(err, KErrNone);
sl@0	757	TEST2(fbuf.iFileReadCount, 0);
sl@0	758	TEST2(fbuf.iFileReadAmount, 0);
sl@0	759	TEST2(fbuf.iFileWriteCount, 0);
sl@0	760	TEST2(fbuf.iFileWriteAmount, 0);
sl@0	761	TEST2(fbuf.iFileSizeCount, 0);
sl@0	762	fbuf.ProfilerReset();
sl@0	763
sl@0	764	//7. Read bytes [5..15]. Part buffered. Pending writes picked up. The content is written to the file.
sl@0	765	err = fbuf.Read(5, buf1);
sl@0	766	TEST2(err, KErrNone);
sl@0	767	TEST2(fbuf.iFileReadCount, 1);
sl@0	768	TEST2(fbuf.iFileReadAmount, 5);
sl@0	769	TEST2(fbuf.iFileWriteCount, 1);
sl@0	770	TEST2(fbuf.iFileWriteAmount, 10);
sl@0	771	TEST2(fbuf.iFileSizeCount, 0);
sl@0	772	fbuf.ProfilerReset();
sl@0	773	VerifyFileContent(buf1, 5);
sl@0	774
sl@0	775	fbuf.Close();
sl@0	776	}
sl@0	777
sl@0	778	/**
sl@0	779	@SYMTestCaseID PDS-SQL-UT-4141
sl@0	780	@SYMTestCaseDesc RFileBuf64::SetReadAheadSize() test.
sl@0	781	The test iterates over all existing drives.
sl@0	782	For each R/W drive a test file is created using RFileBuf64 class.
sl@0	783	Then the test collects information regarding the block size, cluster size and
sl@0	784	read buffer size and calls RFileBuf64::SetReadAheadSize() with these parameters
sl@0	785	to check how the read-ahead buffer size will be recalculated.
sl@0	786	@SYMTestActions RFileBuf64::SetReadAheadSize() test.
sl@0	787	@SYMTestExpectedResults Test must not fail
sl@0	788	@SYMTestPriority High
sl@0	789	@SYMREQ REQ12106
sl@0	790	REQ12109
sl@0	791	*/
sl@0	792	void SetReadAheadSizeTest()
sl@0	793	{
sl@0	794	TheTest.Printf(_L("==================\r\n"));
sl@0	795	_LIT(KType1, "Not present");
sl@0	796	_LIT(KType2, "Unknown");
sl@0	797	_LIT(KType3, "Floppy");
sl@0	798	_LIT(KType4, "Hard disk");
sl@0	799	_LIT(KType5, "CD ROM");
sl@0	800	_LIT(KType6, "RAM disk");
sl@0	801	_LIT(KType7, "Flash");
sl@0	802	_LIT(KType8, "ROM drive");
sl@0	803	_LIT(KType9, "Remote drive");
sl@0	804	_LIT(KType10,"NAND flash");
sl@0	805	_LIT(KType11,"Rotating media");
sl@0	806
sl@0	807	for(TInt drive=EDriveA;drive<=EDriveZ;++drive)
sl@0	808	{
sl@0	809	TDriveInfo driveInfo;
sl@0	810	TInt err = TheFs.Drive(driveInfo, drive);
sl@0	811	if(err == KErrNone)
sl@0	812	{
sl@0	813	TVolumeInfo vinfo;
sl@0	814	err = TheFs.Volume(vinfo, drive);
sl@0	815	if(err == KErrNone)
sl@0	816	{
sl@0	817	TVolumeIOParamInfo vparam;
sl@0	818	err = TheFs.VolumeIOParam(drive, vparam);
sl@0	819	TEST2(err, KErrNone);
sl@0	820	TBuf8<128> vinfoex8;
sl@0	821	err = TheFs.QueryVolumeInfoExt(drive, EFileSystemSubType, vinfoex8);
sl@0	822	TEST2(err, KErrNone);
sl@0	823	TPtrC vinfoex((const TUint16*)(vinfoex8.Ptr() + 8), vinfoex8[0]);
sl@0	824	TPtrC KMediaTypeNames[] = {KType1(), KType2(), KType3(), KType4(), KType5(), KType6(), KType7(), KType8(), KType9(), KType10(), KType11()};
sl@0	825	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	826	TheTest.Printf(_L(" Size: %ld bytes.\r\n"), vinfo.iSize);
sl@0	827	TheTest.Printf(_L(" Block size=%d, Cluster size=%d, Read buffer size=%d.\r\n"), vparam.iBlockSize, vparam.iClusterSize, vparam.iRecReadBufSize);
sl@0	828	if(driveInfo.iType == EMediaRam \|\| driveInfo.iType == EMediaHardDisk \|\| driveInfo.iType == EMediaFlash \|\| driveInfo.iType == EMediaNANDFlash)
sl@0	829	{
sl@0	830	TDriveUnit drvUnit(drive);
sl@0	831	TDriveName drvName = drvUnit.Name();
sl@0	832	TParse parse;
sl@0	833	parse.Set(KTestFile2, &drvName, NULL);
sl@0	834	TheDbName.Copy(parse.FullName());
sl@0	835	TRAP(err, BaflUtils::EnsurePathExistsL(TheFs, TheDbName));
sl@0	836	if(err == KErrNone \|\| err == KErrAlreadyExists)
sl@0	837	{
sl@0	838	(void)TheFs.Delete(TheDbName);
sl@0	839	RFileBuf64 fbuf64(8 * 1024);
sl@0	840	err = fbuf64.Create(TheFs, TheDbName, EFileRead \| EFileWrite);
sl@0	841	TEST2(err, KErrNone);
sl@0	842	TInt readAhead = fbuf64.SetReadAheadSize(vparam.iBlockSize, vparam.iRecReadBufSize);
sl@0	843	TheTest.Printf(_L(" Read-ahead size=%d.\r\n"), readAhead);
sl@0	844	fbuf64.Close();
sl@0	845	(void)TheFs.Delete(TheDbName);
sl@0	846	}
sl@0	847	else
sl@0	848	{
sl@0	849	TheTest.Printf(_L("Drive %C. BaflUtils::EnsurePathExistsL() has failed with err=%d.\r\n"), 'A' + drive, err);
sl@0	850	}
sl@0	851	}
sl@0	852	}
sl@0	853	else
sl@0	854	{
sl@0	855	TheTest.Printf(_L("Drive %C. RFs::Volume() has failed with err=%d.\r\n"), 'A' + drive, err);
sl@0	856	}
sl@0	857	}
sl@0	858	else
sl@0	859	{
sl@0	860	TheTest.Printf(_L("Drive %C. RFs::Drive() has failed with err=%d.\r\n"), 'A' + drive, err);
sl@0	861	}
sl@0	862	}
sl@0	863	TheTest.Printf(_L("==================\r\n"));
sl@0	864	//
sl@0	865	RFileBuf64 fbuf64(8 * 1024);//buffer capacity = 8Kb
sl@0	866
sl@0	867	//"ReadRecBufSize" defined and is power of two, the "BlockSize" is also defined and is power of two
sl@0	868	TInt err2 = fbuf64.Create(TheFs, TheDbName, EFileRead \| EFileWrite);
sl@0	869	TEST2(err2, KErrNone);
sl@0	870	TInt blockSize = 4096; TInt readRecBufSize = 2048;
sl@0	871	TInt readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0	872	TEST2(readAhead2, readRecBufSize);
sl@0	873	fbuf64.Close();
sl@0	874
sl@0	875	//"ReadRecBufSize" defined and is power of two but is less than the default read-ahead value
sl@0	876	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead \| EFileWrite);
sl@0	877	TEST2(err2, KErrNone);
sl@0	878	blockSize = 0; readRecBufSize = 128;
sl@0	879	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0	880	TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
sl@0	881	fbuf64.Close();
sl@0	882
sl@0	883	//"ReadRecBufSize" defined and is power of two but is bigger than the buffer capacity
sl@0	884	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead \| EFileWrite);
sl@0	885	TEST2(err2, KErrNone);
sl@0	886	blockSize = -10; readRecBufSize = fbuf64.iCapacity * 2;
sl@0	887	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0	888	TEST2(readAhead2, fbuf64.iCapacity);
sl@0	889	fbuf64.Close();
sl@0	890
sl@0	891	//"ReadRecBufSize" defined but is not power of two, "BlockSize" defined but is less than the default read-ahead value
sl@0	892	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead \| EFileWrite);
sl@0	893	TEST2(err2, KErrNone);
sl@0	894	blockSize = 512; readRecBufSize = 4000;
sl@0	895	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0	896	TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
sl@0	897	fbuf64.Close();
sl@0	898
sl@0	899	//"ReadRecBufSize" defined but is not power of two, "BlockSize" defined and is bigger than the default read-ahead value
sl@0	900	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead \| EFileWrite);
sl@0	901	TEST2(err2, KErrNone);
sl@0	902	blockSize = 4096; readRecBufSize = 4000;
sl@0	903	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0	904	TEST2(readAhead2, blockSize);
sl@0	905	fbuf64.Close();
sl@0	906
sl@0	907	//"ReadRecBufSize" defined but is not power of two, "BlockSize" defined and is bigger than the buffer capacity
sl@0	908	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead \| EFileWrite);
sl@0	909	TEST2(err2, KErrNone);
sl@0	910	blockSize = fbuf64.iCapacity * 2; readRecBufSize = 1;
sl@0	911	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0	912	TEST2(readAhead2, fbuf64.iCapacity);
sl@0	913	fbuf64.Close();
sl@0	914
sl@0	915	//"ReadRecBufSize" negative, "BlockSize" defined but is not power of two
sl@0	916	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead \| EFileWrite);
sl@0	917	TEST2(err2, KErrNone);
sl@0	918	blockSize = 1000; readRecBufSize = -2;
sl@0	919	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0	920	TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
sl@0	921	fbuf64.Close();
sl@0	922
sl@0	923	//"ReadRecBufSize" negative, "BlockSize" negative
sl@0	924	err2 = fbuf64.Open(TheFs, TheDbName, EFileRead \| EFileWrite);
sl@0	925	TEST2(err2, KErrNone);
sl@0	926	blockSize = -1; readRecBufSize = -2;
sl@0	927	readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
sl@0	928	TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
sl@0	929	fbuf64.Close();
sl@0	930	//
sl@0	931	(void)TheFs.Delete(TheDbName);
sl@0	932	}
sl@0	933
sl@0	934	/**
sl@0	935	@SYMTestCaseID PDS-SQL-UT-4142
sl@0	936	@SYMTestCaseDesc RFileBuf64 OOM test.
sl@0	937	The test calls RFileBuf64:Create(), RFileBuf64:Open() and RFileBuf64:Temp() in an OOM
sl@0	938	simulation loop and verifies that no memory is leaked.
sl@0	939	@SYMTestActions RFileBuf64 OOM test.
sl@0	940	@SYMTestExpectedResults Test must not fail
sl@0	941	@SYMTestPriority High
sl@0	942	@SYMREQ REQ12106
sl@0	943	REQ12109
sl@0	944	*/
sl@0	945	void OomTest(TOomTestType aOomTestType)
sl@0	946	{
sl@0	947	(void)TheFs.Delete(KTestFile);
sl@0	948
sl@0	949	if(aOomTestType == EOomOpenTest)
sl@0	950	{
sl@0	951	RFile64 file;
sl@0	952	TInt err2 = file.Create(TheFs, KTestFile, EFileWrite \| EFileRead);
sl@0	953	file.Close();
sl@0	954	TEST2(err2, KErrNone);
sl@0	955	}
sl@0	956
sl@0	957	TFileName tmpFileName;
sl@0	958	TInt err = KErrNoMemory;
sl@0	959	TInt failingAllocationNo = 0;
sl@0	960	RFileBuf64 fbuf(1024);
sl@0	961	TheTest.Printf(_L("Iteration:\r\n"));
sl@0	962	while(err == KErrNoMemory)
sl@0	963	{
sl@0	964	TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0	965
sl@0	966	MarkHandles();
sl@0	967	MarkAllocatedCells();
sl@0	968
sl@0	969	__UHEAP_MARK;
sl@0	970	__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
sl@0	971
sl@0	972	switch(aOomTestType)
sl@0	973	{
sl@0	974	case EOomCreateTest:
sl@0	975	err = fbuf.Create(TheFs, KTestFile, EFileWrite \| EFileRead);
sl@0	976	break;
sl@0	977	case EOomOpenTest:
sl@0	978	err = fbuf.Open(TheFs, KTestFile, EFileWrite \| EFileRead);
sl@0	979	break;
sl@0	980	case EOomTempTest:
sl@0	981	{
sl@0	982	err = fbuf.Temp(TheFs, KTestDir, tmpFileName, EFileWrite \| EFileRead);
sl@0	983	}
sl@0	984	break;
sl@0	985	default:
sl@0	986	TEST(0);
sl@0	987	break;
sl@0	988	}
sl@0	989	fbuf.Close();
sl@0	990
sl@0	991	__UHEAP_RESET;
sl@0	992	__UHEAP_MARKEND;
sl@0	993
sl@0	994	CheckAllocatedCells();
sl@0	995	CheckHandles();
sl@0	996
sl@0	997	TEntry entry;
sl@0	998	if(err != KErrNoMemory)
sl@0	999	{
sl@0	1000	TEST2(err, KErrNone);
sl@0	1001	}
sl@0	1002	else if(aOomTestType == EOomCreateTest)
sl@0	1003	{
sl@0	1004	TInt err2 = TheFs.Entry(KTestFile, entry);
sl@0	1005	TEST2(err2, KErrNotFound);
sl@0	1006	}
sl@0	1007	else if(aOomTestType == EOomTempTest)
sl@0	1008	{
sl@0	1009	if(tmpFileName.Size() > 0)
sl@0	1010	{
sl@0	1011	TInt err2 = TheFs.Entry(tmpFileName, entry);
sl@0	1012	TEST2(err2, KErrNotFound);
sl@0	1013	}
sl@0	1014	}
sl@0	1015	}
sl@0	1016	TEST2(err, KErrNone);
sl@0	1017	TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0	1018
sl@0	1019	if(aOomTestType == EOomTempTest)
sl@0	1020	{
sl@0	1021	(void)TheFs.Delete(tmpFileName);
sl@0	1022	}
sl@0	1023	(void)TheFs.Delete(KTestFile);
sl@0	1024	}
sl@0	1025
sl@0	1026	/**
sl@0	1027	@SYMTestCaseID PDS-SQL-UT-4195
sl@0	1028	@SYMTestCaseDesc RFileBuf64::Create() file I/O error simulation test.
sl@0	1029	The test calls RFileBuf64:Create() in a file I/O error simulation loop.
sl@0	1030	@SYMTestActions RFileBuf64::Create() file I/O error simulation test.
sl@0	1031	@SYMTestExpectedResults Test must not fail
sl@0	1032	@SYMTestPriority High
sl@0	1033	@SYMDEF DEF145198
sl@0	1034	*/
sl@0	1035	void CreateFileIoErrTest()
sl@0	1036	{
sl@0	1037	TInt err = KErrGeneral;
sl@0	1038	TInt cnt = 0;
sl@0	1039	for(;err<KErrNone;++cnt)
sl@0	1040	{
sl@0	1041	TheTest.Printf(_L("===Iteration %d. Simulated error:\r\n"), cnt);
sl@0	1042	for (TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
sl@0	1043	{
sl@0	1044	TheTest.Printf(_L("%d "), fsError);
sl@0	1045	__UHEAP_MARK;
sl@0	1046	(void)TheFs.SetErrorCondition(fsError, cnt);
sl@0	1047	RFileBuf64 fbuf(1024);//buffer capacity = 1024 bytes
sl@0	1048	err = fbuf.Create(TheFs, KTestFile3, EFileRead \| EFileWrite);
sl@0	1049	(void)TheFs.SetErrorCondition(KErrNone);
sl@0	1050	fbuf.Close();
sl@0	1051	__UHEAP_MARKEND;
sl@0	1052	TInt err2 = TheFs.Delete(KTestFile3);
sl@0	1053	TInt expectedErr = err == KErrNone ? KErrNone : KErrNotFound;
sl@0	1054	TEST2(err2, expectedErr);
sl@0	1055	}
sl@0	1056	TheTest.Printf(_L("\r\n"));
sl@0	1057	}
sl@0	1058	TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\n"), cnt);
sl@0	1059	}
sl@0	1060
sl@0	1061	/**
sl@0	1062	@SYMTestCaseID PDS-SQL-UT-4196
sl@0	1063	@SYMTestCaseDesc RFileBuf64::Open() file I/O error simulation test.
sl@0	1064	The test calls RFileBuf64:Open() in a file I/O error simulation loop.
sl@0	1065	@SYMTestActions RFileBuf64::Open() file I/O error simulation test.
sl@0	1066	@SYMTestExpectedResults Test must not fail
sl@0	1067	@SYMTestPriority High
sl@0	1068	@SYMDEF DEF145198
sl@0	1069	*/
sl@0	1070	void OpenFileIoErrTest()
sl@0	1071	{
sl@0	1072	RFileBuf64 fbuf(1024);//buffer capacity = 1024 bytes
sl@0	1073	TInt err = fbuf.Create(TheFs, KTestFile3, EFileRead \| EFileWrite);
sl@0	1074	fbuf.Close();
sl@0	1075	TEST2(err, KErrNone);
sl@0	1076	err = KErrGeneral;
sl@0	1077	TInt cnt = 0;
sl@0	1078	for(;err<KErrNone;++cnt)
sl@0	1079	{
sl@0	1080	TheTest.Printf(_L("===Iteration %d. Simulated error:\r\n"), cnt);
sl@0	1081	for (TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
sl@0	1082	{
sl@0	1083	TheTest.Printf(_L("%d "), fsError);
sl@0	1084	__UHEAP_MARK;
sl@0	1085	(void)TheFs.SetErrorCondition(fsError, cnt);
sl@0	1086	err = fbuf.Open(TheFs, KTestFile3, EFileRead \| EFileWrite);
sl@0	1087	(void)TheFs.SetErrorCondition(KErrNone);
sl@0	1088	fbuf.Close();
sl@0	1089	__UHEAP_MARKEND;
sl@0	1090	}
sl@0	1091	TheTest.Printf(_L("\r\n"));
sl@0	1092	}
sl@0	1093	TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\n"), cnt);
sl@0	1094	(void)TheFs.Delete(KTestFile3);
sl@0	1095	}
sl@0	1096
sl@0	1097	/**
sl@0	1098	@SYMTestCaseID PDS-SQL-UT-4197
sl@0	1099	@SYMTestCaseDesc RFileBuf64::Temp() file I/O error simulation test.
sl@0	1100	The test calls RFileBuf64:Temp() in a file I/O error simulation loop.
sl@0	1101	@SYMTestActions RFileBuf64::temp() file I/O error simulation test.
sl@0	1102	@SYMTestExpectedResults Test must not fail
sl@0	1103	@SYMTestPriority High
sl@0	1104	@SYMDEF DEF145198
sl@0	1105	*/
sl@0	1106	void TempFileIoErrTest()
sl@0	1107	{
sl@0	1108	TInt err = KErrGeneral;
sl@0	1109	TInt cnt = 0;
sl@0	1110	for(;err<KErrNone;++cnt)
sl@0	1111	{
sl@0	1112	TheTest.Printf(_L("===Iteration %d. Simulated error:\r\n"), cnt);
sl@0	1113	for (TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
sl@0	1114	{
sl@0	1115	TheTest.Printf(_L("%d "), fsError);
sl@0	1116	__UHEAP_MARK;
sl@0	1117	(void)TheFs.SetErrorCondition(fsError, cnt);
sl@0	1118	RFileBuf64 fbuf(1024);//buffer capacity = 1024 bytes
sl@0	1119	TFileName tmpFileName;
sl@0	1120	err = fbuf.Temp(TheFs, KTestDir, tmpFileName, EFileWrite \| EFileRead);
sl@0	1121	(void)TheFs.SetErrorCondition(KErrNone);
sl@0	1122	fbuf.Close();
sl@0	1123	__UHEAP_MARKEND;
sl@0	1124	TInt err2 = TheFs.Delete(tmpFileName);
sl@0	1125	TInt expectedErr = err == KErrNone ? KErrNone : KErrNotFound;
sl@0	1126	TEST2(err2, expectedErr);
sl@0	1127	}
sl@0	1128	TheTest.Printf(_L("\r\n"));
sl@0	1129	}
sl@0	1130	TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\n"), cnt);
sl@0	1131	}
sl@0	1132
sl@0	1133	/**
sl@0	1134	@SYMTestCaseID PDS-SQL-UT-4207
sl@0	1135	@SYMTestCaseDesc RFileBuf64::Write() OOM test.
sl@0	1136	The test calls RFileBuf64:Write() in an OOM
sl@0	1137	simulation loop and verifies that no memory is leaked.
sl@0	1138	The test also check that RFileBuf::DoSetCapacity() correctly operates in
sl@0	1139	"out of memory" situation.
sl@0	1140	@SYMTestActions RFileBuf64::Write() OOM test.
sl@0	1141	@SYMTestExpectedResults Test must not fail
sl@0	1142	@SYMTestPriority High
sl@0	1143	@SYMDEF 380056
sl@0	1144	*/
sl@0	1145	void WriteOomTest()
sl@0	1146	{
sl@0	1147	HBufC8* databuf = HBufC8::New(KPageSize);
sl@0	1148	TEST(databuf != NULL);
sl@0	1149	TPtr8 dataptr = databuf->Des();
sl@0	1150	dataptr.SetLength(KPageSize);
sl@0	1151	dataptr.Fill(TChar(KChar));
sl@0	1152
sl@0	1153	TInt err = KErrNoMemory;
sl@0	1154	TInt failingAllocationNo = 0;
sl@0	1155	TheTest.Printf(_L("Iteration:\r\n"));
sl@0	1156	while(err == KErrNoMemory)
sl@0	1157	{
sl@0	1158	TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0	1159
sl@0	1160	(void)TheFs.Delete(KTestFile);
sl@0	1161
sl@0	1162	MarkHandles();
sl@0	1163	MarkAllocatedCells();
sl@0	1164
sl@0	1165	__UHEAP_MARK;
sl@0	1166	__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
sl@0	1167
sl@0	1168	const TInt KDefaultBufCapacity = 1024;
sl@0	1169	RFileBuf64 fbuf(KDefaultBufCapacity);
sl@0	1170	err = fbuf.Create(TheFs, KTestFile, EFileWrite \| EFileRead);
sl@0	1171	if(err == KErrNone)
sl@0	1172	{
sl@0	1173	err = fbuf.Write(0LL, dataptr);
sl@0	1174	}
sl@0	1175	fbuf.Close();
sl@0	1176
sl@0	1177	__UHEAP_RESET;
sl@0	1178	__UHEAP_MARKEND;
sl@0	1179
sl@0	1180	CheckAllocatedCells();
sl@0	1181	CheckHandles();
sl@0	1182	}
sl@0	1183	TEST2(err, KErrNone);
sl@0	1184	RFile64 file;
sl@0	1185	err = file.Open(TheFs, KTestFile, EFileRead);
sl@0	1186	TEST2(err, KErrNone);
sl@0	1187	dataptr.Zero();
sl@0	1188	err = file.Read(dataptr);
sl@0	1189	TEST2(err, KErrNone);
sl@0	1190	file.Close();
sl@0	1191	TEST2(dataptr.Length(), KPageSize);
sl@0	1192	for(TInt i=0;i<KPageSize;++i)
sl@0	1193	{
sl@0	1194	TEST(dataptr[i] == KChar);
sl@0	1195	}
sl@0	1196	TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0	1197
sl@0	1198	//The file is left undeleted - to be used in ReadOomTest().
sl@0	1199	delete databuf;
sl@0	1200	}
sl@0	1201
sl@0	1202	/**
sl@0	1203	@SYMTestCaseID PDS-SQL-UT-4208
sl@0	1204	@SYMTestCaseDesc RFileBuf64::Read() OOM test.
sl@0	1205	The test calls RFileBuf64:Read() in an OOM
sl@0	1206	simulation loop and verifies that no memory is leaked.
sl@0	1207	The test also check that RFileBuf::DoSetCapacity() correctly operates in
sl@0	1208	"out of memory" situation.
sl@0	1209	@SYMTestActions RFileBuf64::Read() OOM test.
sl@0	1210	@SYMTestExpectedResults Test must not fail
sl@0	1211	@SYMTestPriority High
sl@0	1212	@SYMDEF 380056
sl@0	1213	*/
sl@0	1214	void ReadOomTest()
sl@0	1215	{
sl@0	1216	HBufC8* databuf = HBufC8::New(KPageSize);
sl@0	1217	TEST(databuf != NULL);
sl@0	1218	TPtr8 dataptr = databuf->Des();
sl@0	1219
sl@0	1220	TInt err = KErrNoMemory;
sl@0	1221	TInt failingAllocationNo = 0;
sl@0	1222	TheTest.Printf(_L("Iteration:\r\n"));
sl@0	1223	while(err == KErrNoMemory)
sl@0	1224	{
sl@0	1225	TheTest.Printf(_L(" %d"), ++failingAllocationNo);
sl@0	1226
sl@0	1227	MarkHandles();
sl@0	1228	MarkAllocatedCells();
sl@0	1229
sl@0	1230	__UHEAP_MARK;
sl@0	1231	__UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
sl@0	1232
sl@0	1233	const TInt KDefaultBufCapacity = 1024;
sl@0	1234	RFileBuf64 fbuf(KDefaultBufCapacity);
sl@0	1235	err = fbuf.Open(TheFs, KTestFile, EFileRead);
sl@0	1236	if(err == KErrNone)
sl@0	1237	{
sl@0	1238	err = fbuf.Read(0LL, dataptr);
sl@0	1239	}
sl@0	1240	fbuf.Close();
sl@0	1241
sl@0	1242	__UHEAP_RESET;
sl@0	1243	__UHEAP_MARKEND;
sl@0	1244
sl@0	1245	CheckAllocatedCells();
sl@0	1246	CheckHandles();
sl@0	1247	}
sl@0	1248	TEST2(err, KErrNone);
sl@0	1249	RFile64 file;
sl@0	1250	err = file.Open(TheFs, KTestFile, EFileRead);
sl@0	1251	TEST2(err, KErrNone);
sl@0	1252	dataptr.Zero();
sl@0	1253	err = file.Read(dataptr);
sl@0	1254	TEST2(err, KErrNone);
sl@0	1255	file.Close();
sl@0	1256	TEST2(dataptr.Length(), KPageSize);
sl@0	1257	for(TInt i=0;i<KPageSize;++i)
sl@0	1258	{
sl@0	1259	TEST(dataptr[i] == KChar);
sl@0	1260	}
sl@0	1261	TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
sl@0	1262
sl@0	1263	(void)TheFs.Delete(KTestFile);
sl@0	1264	delete databuf;
sl@0	1265	}
sl@0	1266
sl@0	1267	/**
sl@0	1268	@SYMTestCaseID PDS-SQL-CT-4212
sl@0	1269	@SYMTestCaseDesc RFileBuf64::Write() test.
sl@0	1270	The test performs file write operations using RFileBuf64 class.
sl@0	1271	Teh test sumilates the write operation at the conditions:
sl@0	1272
sl@0	1273	1. There are 8 pages to be writted to the file.
sl@0	1274	2. Each page is 16 bytes
sl@0	1275	3. The size of RFileBuf64 is 4 pages, i.e. 64 bytes.
sl@0	1276	4. The order of write is not sequential.
sl@0	1277
sl@0	1278	@SYMTestActions Write database pages.
sl@0	1279	@SYMTestExpectedResults Test must not fail
sl@0	1280	@SYMTestPriority High
sl@0	1281	*/
sl@0	1282	void TestSetSizeCounter()
sl@0	1283	{
sl@0	1284	const TInt KPageSize = 16;
sl@0	1285	const TInt KBufSize = 4 * KPageSize;
sl@0	1286	RFileBuf64 fbuf(KBufSize);
sl@0	1287	(void)TheFs.Delete(KTestFile);
sl@0	1288	TInt err = fbuf.Create(TheFs, KTestFile, EFileRead \| EFileWrite);
sl@0	1289	TEST2(err, KErrNone);
sl@0	1290	const TInt KMaxPage = 8;
sl@0	1291	TUint8 fileData[KMaxPage][KPageSize];
sl@0	1292	TPtrC8 pageData[KMaxPage];
sl@0	1293	for(TInt i = 0;i <KMaxPage;++i)
sl@0	1294	{
sl@0	1295	Mem::Fill(fileData[i], KPageSize, TChar('a' + i));
sl@0	1296	const TUint8* p = fileData[i];
sl@0	1297	pageData[i].Set(p, KPageSize);
sl@0	1298	}
sl@0	1299	//
sl@0	1300	fbuf.ProfilerReset();
sl@0	1301	//Write the first 4 pages
sl@0	1302	for (TInt ii = 0; ii < 4; ii++)
sl@0	1303	{
sl@0	1304	err = fbuf.Write(ii * KPageSize, pageData[ii]);
sl@0	1305	TEST2(err, KErrNone);
sl@0	1306	}
sl@0	1307	//Write page #2
sl@0	1308	err = fbuf.Write(2 * KPageSize, pageData[2]);
sl@0	1309	TEST2(err, KErrNone);
sl@0	1310	//
sl@0	1311	TEST2(fbuf.iFileWriteCount, 0);
sl@0	1312	TEST2(fbuf.iFileSetSizeCount, 0);
sl@0	1313	//Write pages 5, 4, 6, 7
sl@0	1314	err = fbuf.Write(5 * KPageSize, pageData[5]);
sl@0	1315	TEST2(err, KErrNone);
sl@0	1316	//
sl@0	1317	TEST2(fbuf.iFileWriteCount, 1);
sl@0	1318	TEST2(fbuf.iFileSetSizeCount, 0);
sl@0	1319	//
sl@0	1320	err = fbuf.Write(4 * KPageSize, pageData[4]);
sl@0	1321	TEST2(err, KErrNone);
sl@0	1322	err = fbuf.Write(6 * KPageSize, pageData[6]);
sl@0	1323	TEST2(err, KErrNone);
sl@0	1324	err = fbuf.Write(7 * KPageSize, pageData[7]);
sl@0	1325	TEST2(err, KErrNone);
sl@0	1326	//
sl@0	1327	TEST2(fbuf.iFileWriteCount, 1);
sl@0	1328	TEST2(fbuf.iFileSetSizeCount, 0);
sl@0	1329	//
sl@0	1330	err = fbuf.Flush();
sl@0	1331	TEST2(err, KErrNone);
sl@0	1332	//
sl@0	1333	TEST2(fbuf.iFileWriteCount, 2);
sl@0	1334	TEST2(fbuf.iFileSetSizeCount, 0);
sl@0	1335	//
sl@0	1336	fbuf.Close();
sl@0	1337	(void)TheFs.Delete(KTestFile);
sl@0	1338	}
sl@0	1339
sl@0	1340	///////////////////////////////////////////////////////////////////////////////////////
sl@0	1341
sl@0	1342	#ifdef _DEBUG
sl@0	1343
sl@0	1344	//Panic thread function.
sl@0	1345	//It will cast aData parameter to a TFunctor pointer and call it.
sl@0	1346	//The expectation is that the called function will panic and kill the panic thread.
sl@0	1347	TInt ThreadFunc(void* aData)
sl@0	1348	{
sl@0	1349	CTrapCleanup* tc = CTrapCleanup::New();
sl@0	1350	TEST(tc != NULL);
sl@0	1351
sl@0	1352	User::SetJustInTime(EFalse); // disable debugger panic handling
sl@0	1353
sl@0	1354	TFunctor* obj = reinterpret_cast<TFunctor*> (aData);
sl@0	1355	TEST(obj != NULL);
sl@0	1356	(*obj)();//call the panic function
sl@0	1357
sl@0	1358	delete tc;
sl@0	1359
sl@0	1360	return KErrNone;
sl@0	1361	}
sl@0	1362
sl@0	1363	//Panic test.
sl@0	1364	//PanicTest function will create a new thread - panic thread, giving it a pointer to the function which has to
sl@0	1365	//be executed and the expectation is that the function will panic and kill the panic thread.
sl@0	1366	//PanicTest function will check the panic thread exit code, exit category and the panic code.
sl@0	1367	void PanicTest(TFunctor& aFunctor, TExitType aExpectedExitType, const TDesC& aExpectedCategory, TInt aExpectedPanicCode)
sl@0	1368	{
sl@0	1369	RThread thread;
sl@0	1370	_LIT(KThreadName,"SqlFileBufPanicThread");
sl@0	1371	TEST2(thread.Create(KThreadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&aFunctor, EOwnerThread), KErrNone);
sl@0	1372
sl@0	1373	TRequestStatus status;
sl@0	1374	thread.Logon(status);
sl@0	1375	TEST2(status.Int(), KRequestPending);
sl@0	1376	thread.Resume();
sl@0	1377	User::WaitForRequest(status);
sl@0	1378	User::SetJustInTime(ETrue); // enable debugger panic handling
sl@0	1379
sl@0	1380	TEST2(thread.ExitType(), aExpectedExitType);
sl@0	1381	TEST(thread.ExitCategory() == aExpectedCategory);
sl@0	1382	TEST2(thread.ExitReason(), aExpectedPanicCode);
sl@0	1383
sl@0	1384	CLOSE_AND_WAIT(thread);
sl@0	1385	}
sl@0	1386
sl@0	1387	////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	1388	////////////////////////////// Panic test functions /////////////////////////////////////////////////
sl@0	1389	////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0	1390
sl@0	1391	//Panic when calling RFileBuf64::RFileBuf64() with an invalid buffer capacity value.
sl@0	1392	class TSqlFileBuf_InvalidCapacity : public TFunctor
sl@0	1393	{
sl@0	1394	private:
sl@0	1395	virtual void operator()()
sl@0	1396	{
sl@0	1397	RFileBuf64 fbuf(-8192);//panic here - "-8192" - negative buffer capacity
sl@0	1398	}
sl@0	1399	};
sl@0	1400	static TSqlFileBuf_InvalidCapacity TheSqlFileBuf_InvalidCapacity;
sl@0	1401
sl@0	1402	//Panic when calling RFileBuf64::Create() with an invalid file handle.
sl@0	1403	class TSqlFileBuf_InvalidFileHandle1 : public TFunctor
sl@0	1404	{
sl@0	1405	private:
sl@0	1406	virtual void operator()()
sl@0	1407	{
sl@0	1408	RFileBuf64 fbuf(8192);
sl@0	1409	RFs fs;
sl@0	1410	fbuf.Create(fs, _L("aaa.db"), EFileRead);//panic here - invalid file handle
sl@0	1411	}
sl@0	1412	};
sl@0	1413	static TSqlFileBuf_InvalidFileHandle1 TheSqlFileBuf_InvalidFileHandle1;
sl@0	1414
sl@0	1415	//Panic when calling RFileBuf64::Create() with an invalid file name.
sl@0	1416	class TSqlFileBuf_InvalidFileName1 : public TFunctor
sl@0	1417	{
sl@0	1418	private:
sl@0	1419	virtual void operator()()
sl@0	1420	{
sl@0	1421	RFileBuf64 fbuf(8192);
sl@0	1422	RFs fs;
sl@0	1423	TInt err = fs.Connect();
sl@0	1424	TEST2(err, KErrNone);
sl@0	1425	fbuf.Create(fs, KNullDesC, EFileRead);//panic here - invalid file name
sl@0	1426	fs.Close();
sl@0	1427	}
sl@0	1428	};
sl@0	1429	static TSqlFileBuf_InvalidFileName1 TheSqlFileBuf_InvalidFileName1;
sl@0	1430
sl@0	1431	//Panic when calling RFileBuf64::Open() with an invalid file handle.
sl@0	1432	class TSqlFileBuf_InvalidFileHandle2 : public TFunctor
sl@0	1433	{
sl@0	1434	private:
sl@0	1435	virtual void operator()()
sl@0	1436	{
sl@0	1437	RFileBuf64 fbuf(8192);
sl@0	1438	RFs fs;
sl@0	1439	fbuf.Open(fs, _L("aaa.db"), EFileRead);//panic here - invalid file handle
sl@0	1440	}
sl@0	1441	};
sl@0	1442	static TSqlFileBuf_InvalidFileHandle2 TheSqlFileBuf_InvalidFileHandle2;
sl@0	1443
sl@0	1444	//Panic when calling RFileBuf64::Open() with an invalid file name.
sl@0	1445	class TSqlFileBuf_InvalidFileName2 : public TFunctor
sl@0	1446	{
sl@0	1447	private:
sl@0	1448	virtual void operator()()
sl@0	1449	{
sl@0	1450	RFileBuf64 fbuf(8192);
sl@0	1451	RFs fs;
sl@0	1452	TInt err = fs.Connect();
sl@0	1453	TEST2(err, KErrNone);
sl@0	1454	fbuf.Open(fs, KNullDesC, EFileRead);//panic here - invalid file name
sl@0	1455	fs.Close();
sl@0	1456	}
sl@0	1457	};
sl@0	1458	static TSqlFileBuf_InvalidFileName2 TheSqlFileBuf_InvalidFileName2;
sl@0	1459
sl@0	1460	//Panic when calling RFileBuf64::Temp() with an invalid file handle.
sl@0	1461	class TSqlFileBuf_InvalidFileHandle3 : public TFunctor
sl@0	1462	{
sl@0	1463	private:
sl@0	1464	virtual void operator()()
sl@0	1465	{
sl@0	1466	RFileBuf64 fbuf(8192);
sl@0	1467	RFs fs;
sl@0	1468	TFileName fname;
sl@0	1469	fbuf.Temp(fs, _L("c:\\test"), fname, EFileRead);//panic here - invalid file handle
sl@0	1470	}
sl@0	1471	};
sl@0	1472	static TSqlFileBuf_InvalidFileHandle3 TheSqlFileBuf_InvalidFileHandle3;
sl@0	1473
sl@0	1474	//Panic when calling RFileBuf64::AdoptFromClient() with an invalid message handle.
sl@0	1475	class TSqlFileBuf_InvalidMessageHandle : public TFunctor
sl@0	1476	{
sl@0	1477	private:
sl@0	1478	virtual void operator()()
sl@0	1479	{
sl@0	1480	RFileBuf64 fbuf(8192);
sl@0	1481	RMessage2 msg;
sl@0	1482	fbuf.AdoptFromClient(msg, 0, 1);//panic here - invalid message handle
sl@0	1483	}
sl@0	1484	};
sl@0	1485	static TSqlFileBuf_InvalidMessageHandle TheSqlFileBuf_InvalidMessageHandle;
sl@0	1486
sl@0	1487	//Panic when calling RFileBuf64::Read() with an invalid file position.
sl@0	1488	class TSqlFileBuf_InvalidReadPos : public TFunctor
sl@0	1489	{
sl@0	1490	private:
sl@0	1491	virtual void operator()()
sl@0	1492	{
sl@0	1493	RFileBuf64 fbuf(8192);
sl@0	1494	TBuf8<50> buf;
sl@0	1495	fbuf.Read(-1024, buf);//panic here - invalid file position
sl@0	1496	}
sl@0	1497	};
sl@0	1498	static TSqlFileBuf_InvalidReadPos TheSqlFileBuf_InvalidReadPos;
sl@0	1499
sl@0	1500	//Panic when calling RFileBuf64::Write() with an invalid file position.
sl@0	1501	class TSqlFileBuf_InvalidWritePos : public TFunctor
sl@0	1502	{
sl@0	1503	private:
sl@0	1504	virtual void operator()()
sl@0	1505	{
sl@0	1506	RFileBuf64 fbuf(8192);
sl@0	1507	TBuf8<50> buf;
sl@0	1508	fbuf.Write(-1024, buf);//panic here - invalid file position
sl@0	1509	}
sl@0	1510	};
sl@0	1511	static TSqlFileBuf_InvalidWritePos TheSqlFileBuf_InvalidWritePos;
sl@0	1512
sl@0	1513	//Panic when calling RFileBuf64::SetSize() with an invalid file size.
sl@0	1514	class TSqlFileBuf_InvalidSize : public TFunctor
sl@0	1515	{
sl@0	1516	private:
sl@0	1517	virtual void operator()()
sl@0	1518	{
sl@0	1519	RFileBuf64 fbuf(8192);
sl@0	1520	TBuf8<50> buf;
sl@0	1521	fbuf.SetSize(-1024);//panic here - invalid file size
sl@0	1522	}
sl@0	1523	};
sl@0	1524	static TSqlFileBuf_InvalidSize TheSqlFileBuf_InvalidSize;
sl@0	1525
sl@0	1526	#endif //_DEBUG
sl@0	1527
sl@0	1528	/**
sl@0	1529	@SYMTestCaseID PDS-SQL-UT-4236
sl@0	1530	@SYMTestCaseDesc RFileBuf64 panic test.
sl@0	1531	The test runs a thread. The thread will create a RFileBuf64 object
sl@0	1532	and put the object in a situation where the file buffer cannot perform
sl@0	1533	its duties anymore and will raise a panic. The test verifies that the file
sl@0	1534	buffer implementation properly detects anomalities such as bad parameters,
sl@0	1535	null handles, etc...
sl@0	1536	@SYMTestActions RFileBuf64 panic test.
sl@0	1537	@SYMTestExpectedResults Test must not fail
sl@0	1538	@SYMTestPriority High
sl@0	1539	*/
sl@0	1540	void FileBufPanicTest()
sl@0	1541	{
sl@0	1542	#ifdef _DEBUG
sl@0	1543	_LIT(KPanicCategory, "FBuf64");
sl@0	1544	PanicTest(TheSqlFileBuf_InvalidCapacity, EExitPanic, KPanicCategory, 1);
sl@0	1545	PanicTest(TheSqlFileBuf_InvalidFileHandle1, EExitPanic, KPanicCategory, 7);
sl@0	1546	PanicTest(TheSqlFileBuf_InvalidFileName1, EExitPanic, KPanicCategory, 10);
sl@0	1547	PanicTest(TheSqlFileBuf_InvalidFileHandle2, EExitPanic, KPanicCategory, 7);
sl@0	1548	PanicTest(TheSqlFileBuf_InvalidFileName2, EExitPanic, KPanicCategory, 10);
sl@0	1549	PanicTest(TheSqlFileBuf_InvalidFileHandle3, EExitPanic, KPanicCategory, 7);
sl@0	1550	PanicTest(TheSqlFileBuf_InvalidMessageHandle, EExitPanic, KPanicCategory, 8);
sl@0	1551	PanicTest(TheSqlFileBuf_InvalidReadPos, EExitPanic, KPanicCategory, 4);
sl@0	1552	PanicTest(TheSqlFileBuf_InvalidWritePos, EExitPanic, KPanicCategory, 4);
sl@0	1553	PanicTest(TheSqlFileBuf_InvalidSize, EExitPanic, KPanicCategory, 5);
sl@0	1554	#else //_DEBUG
sl@0	1555	TheTest.Printf(_L("This test can be run in _DEBUG mode only!"));
sl@0	1556	#endif//_DEBUG
sl@0	1557	}
sl@0	1558
sl@0	1559	void DoTests()
sl@0	1560	{
sl@0	1561	TheTest.Start(_L(" @SYMTestCaseID:PDS-SQL-UT-4132 RFileBuf64 write test 1"));
sl@0	1562	WriteTest1();
sl@0	1563	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4133 RFileBuf64 write test 2"));
sl@0	1564	WriteTest2();
sl@0	1565	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4134 RFileBuf64 write test 3"));
sl@0	1566	WriteTest3();
sl@0	1567	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4135 RFileBuf64 write test 4"));
sl@0	1568	WriteTest4();
sl@0	1569	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4136 RFileBuf64 write test 5"));
sl@0	1570	WriteTest5();
sl@0	1571	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4137 RFileBuf64 write test 6"));
sl@0	1572	WriteTest6();
sl@0	1573	TheTest.Next( _L("RFileBuf64 read test - preparation"));
sl@0	1574	PrepareReadTest();
sl@0	1575	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4138 RFileBuf64 read test 1"));
sl@0	1576	ReadTest1();
sl@0	1577	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4139 RFileBuf64 read test 2"));
sl@0	1578	ReadTest2();
sl@0	1579	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4140 RFileBuf64 read test 3"));
sl@0	1580	ReadTest3();
sl@0	1581
sl@0	1582	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4141 RFileBuf64::SetReadAheadSize() test"));
sl@0	1583	SetReadAheadSizeTest();
sl@0	1584
sl@0	1585	(void)TheFs.Delete(KTestFile);
sl@0	1586
sl@0	1587	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4142 RFileBuf64::Create() OOM test"));
sl@0	1588	OomTest(EOomCreateTest);
sl@0	1589	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4142 RFileBuf64::Open() OOM test"));
sl@0	1590	OomTest(EOomOpenTest);
sl@0	1591	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4142 RFileBuf64::Temp() OOM test"));
sl@0	1592	OomTest(EOomTempTest);
sl@0	1593	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4207 RFileBuf64::Write() OOM test"));
sl@0	1594	WriteOomTest();
sl@0	1595	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4208 RFileBuf64::Read() OOM test"));
sl@0	1596	ReadOomTest();
sl@0	1597
sl@0	1598	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4195 RFileBuf64::Create() file I/O error simulation test"));
sl@0	1599	CreateFileIoErrTest();
sl@0	1600	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4196 RFileBuf64::Open() file I/O error simulation test"));
sl@0	1601	OpenFileIoErrTest();
sl@0	1602	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4197 RFileBuf64::Temp() file I/O error simulation test"));
sl@0	1603	OpenFileIoErrTest();
sl@0	1604	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-CT-4212 RFileBuf64::Write() test"));
sl@0	1605	TestSetSizeCounter();
sl@0	1606
sl@0	1607	TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4236 RFileBuf64 panic test"));
sl@0	1608	FileBufPanicTest();
sl@0	1609	}
sl@0	1610
sl@0	1611	TInt E32Main()
sl@0	1612	{
sl@0	1613	TheTest.Title();
sl@0	1614
sl@0	1615	CTrapCleanup* tc = CTrapCleanup::New();
sl@0	1616	TheTest(tc != NULL);
sl@0	1617
sl@0	1618	__UHEAP_MARK;
sl@0	1619
sl@0	1620	TestEnvInit();
sl@0	1621	DeleteTestFiles();
sl@0	1622	DoTests();
sl@0	1623	TestEnvDestroy();
sl@0	1624
sl@0	1625	__UHEAP_MARKEND;
sl@0	1626
sl@0	1627	TheTest.End();
sl@0	1628	TheTest.Close();
sl@0	1629
sl@0	1630	delete tc;
sl@0	1631
sl@0	1632	User::Heap().Check();
sl@0	1633	return KErrNone;
sl@0	1634	}
sl@0	1635
sl@0	1636	#else//_SQLPROFILER
sl@0	1637
sl@0	1638	TInt E32Main()
sl@0	1639	{
sl@0	1640	TheTest.Title();
sl@0	1641
sl@0	1642	TheTest.Start(_L("This test works only if the test is built with _SQLPROFILER macro defined!"));
sl@0	1643	TheTest.End();
sl@0	1644	TheTest.Close();
sl@0	1645
sl@0	1646	return KErrNone;
sl@0	1647	}
sl@0	1648
sl@0	1649	#endif//_SQLPROFILER

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--