1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqlfilebuf64.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1649 @@
1.4 +// Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +#include <e32test.h>
1.19 +
1.20 +#ifdef _SQLPROFILER
1.21 +
1.22 +#include <bautils.h>
1.23 +#include "FileBuf64.h"
1.24 +
1.25 +///////////////////////////////////////////////////////////////////////////////////////
1.26 +
1.27 +TBool TheOsCallTimeDetailedProfileEnabled = ETrue;//Needed because the RFileBuf64 source is included directly into this test
1.28 + //nd the sql profiler is enabled (_SQLPROFILER is defined in the MMP file)
1.29 +
1.30 +static RTest TheTest(_L("t_sqlfilebuf64 test"));
1.31 +static RFs TheFs;
1.32 +
1.33 +_LIT(KTestDir, "c:\\test\\");
1.34 +_LIT(KTestFile, "c:\\test\\t_sqlfilebuf64.bin");
1.35 +_LIT(KTestFile2, "\\test\\t_sqlfilebuf64_2.bin");
1.36 +_LIT(KTestFile3, "c:\\test\\t_sqlfilebuf64_3.bin");
1.37 +
1.38 +static TBuf8<1024> TheBuf;
1.39 +static TFileName TheDbName;
1.40 +
1.41 +static TInt TheProcessHandleCount = 0;
1.42 +static TInt TheThreadHandleCount = 0;
1.43 +static TInt TheAllocatedCellsCount = 0;
1.44 +
1.45 +#ifdef _DEBUG
1.46 +static const TInt KBurstRate = 100;
1.47 +#endif
1.48 +
1.49 +enum TOomTestType
1.50 + {
1.51 + EOomCreateTest,
1.52 + EOomOpenTest,
1.53 + EOomTempTest
1.54 + };
1.55 +
1.56 +//Used in read/write OOM tests
1.57 +const TUint8 KChar = 'A';
1.58 +const TInt KPageSize = 32768;
1.59 +
1.60 +///////////////////////////////////////////////////////////////////////////////////////
1.61 +
1.62 +void DeleteTestFiles()
1.63 + {
1.64 + if(TheDbName.Length() > 0)
1.65 + {
1.66 + (void)TheFs.Delete(TheDbName);
1.67 + }
1.68 + (void)TheFs.Delete(KTestFile3);
1.69 + (void)TheFs.Delete(KTestFile);
1.70 + }
1.71 +
1.72 +void TestEnvDestroy()
1.73 + {
1.74 + DeleteTestFiles();
1.75 + TheFs.Close();
1.76 + }
1.77 +
1.78 +///////////////////////////////////////////////////////////////////////////////////////
1.79 +///////////////////////////////////////////////////////////////////////////////////////
1.80 +//Test macros and functions
1.81 +void Check1(TInt aValue, TInt aLine)
1.82 + {
1.83 + if(!aValue)
1.84 + {
1.85 + TestEnvDestroy();
1.86 + RDebug::Print(_L("*** Line %d\r\n"), aLine);
1.87 + TheTest(EFalse, aLine);
1.88 + }
1.89 + }
1.90 +void Check2(TInt aValue, TInt aExpected, TInt aLine)
1.91 + {
1.92 + if(aValue != aExpected)
1.93 + {
1.94 + TestEnvDestroy();
1.95 + RDebug::Print(_L("*** Line %d, Expected result: %d, got: %d\r\n"), aLine, aExpected, aValue);
1.96 + TheTest(EFalse, aLine);
1.97 + }
1.98 + }
1.99 +#define TEST(arg) ::Check1((arg), __LINE__)
1.100 +#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
1.101 +
1.102 +///////////////////////////////////////////////////////////////////////////////////////
1.103 +
1.104 +void TestEnvInit()
1.105 + {
1.106 + TInt err = TheFs.Connect();
1.107 + TEST2(err, KErrNone);
1.108 +
1.109 + err = TheFs.MkDir(KTestDir);
1.110 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.111 + }
1.112 +
1.113 +///////////////////////////////////////////////////////////////////////////////////////
1.114 +
1.115 +static void MarkHandles()
1.116 + {
1.117 + RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);
1.118 + }
1.119 +
1.120 +static void MarkAllocatedCells()
1.121 + {
1.122 + TheAllocatedCellsCount = User::CountAllocCells();
1.123 + }
1.124 +
1.125 +static void CheckAllocatedCells()
1.126 + {
1.127 + TInt allocatedCellsCount = User::CountAllocCells();
1.128 + TEST2(allocatedCellsCount, TheAllocatedCellsCount);
1.129 + }
1.130 +
1.131 +static void CheckHandles()
1.132 + {
1.133 + TInt endProcessHandleCount;
1.134 + TInt endThreadHandleCount;
1.135 +
1.136 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.137 +
1.138 + TEST2(TheProcessHandleCount, endProcessHandleCount);
1.139 + TEST2(TheThreadHandleCount, endThreadHandleCount);
1.140 + }
1.141 +
1.142 +static void VerifyFileContent(const TDesC8& aPattern)
1.143 + {
1.144 + TheBuf.Zero();
1.145 +
1.146 + RFile64 file;
1.147 + TInt err = file.Open(TheFs, KTestFile, EFileShareReadersOrWriters);
1.148 + TEST2(err, KErrNone);
1.149 +
1.150 + TInt64 fsize;
1.151 + err = file.Size(fsize);
1.152 + TEST2(err, KErrNone);
1.153 + TEST2((TInt)fsize, aPattern.Length());
1.154 +
1.155 + err = file.Read(TheBuf, aPattern.Length());
1.156 + TEST2(err, KErrNone);
1.157 +
1.158 + file.Close();
1.159 +
1.160 + err = TheBuf.Compare(aPattern);
1.161 + TEST2(err, 0);
1.162 + }
1.163 +
1.164 +static void VerifyFileContent(const TDesC8& aPattern, TInt64 aFilePos)
1.165 + {
1.166 + __ASSERT_DEBUG(aFilePos >= 0, User::Invariant());
1.167 +
1.168 + TheBuf.Zero();
1.169 +
1.170 + RFile64 file;
1.171 + TInt err = file.Open(TheFs, KTestFile, EFileShareReadersOrWriters);
1.172 + TEST2(err, KErrNone);
1.173 +
1.174 + err = file.Read(aFilePos, TheBuf, aPattern.Length());
1.175 + TEST2(err, KErrNone);
1.176 +
1.177 + file.Close();
1.178 +
1.179 + err = TheBuf.Compare(aPattern);
1.180 + TEST2(err, 0);
1.181 + }
1.182 +
1.183 +/**
1.184 +@SYMTestCaseID PDS-SQL-UT-4132
1.185 +@SYMTestCaseDesc RFileBuf64 write test 1.
1.186 + The test performs file write operations using RFileBuf64 class.
1.187 + The write positions are inside the buffer or right at the end of the buffer.
1.188 + The purpose of the test: to verify the logic of RFileBuf64::Write().
1.189 +@SYMTestActions RFileBuf64 write test 1.
1.190 +@SYMTestExpectedResults Test must not fail
1.191 +@SYMTestPriority High
1.192 +@SYMREQ REQ12106
1.193 + REQ12109
1.194 +*/
1.195 +void WriteTest1()
1.196 + {
1.197 + RFileBuf64 fbuf(1024);
1.198 + TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
1.199 + TEST2(err, KErrNone);
1.200 + fbuf.ProfilerReset();
1.201 +
1.202 + //Zero write request
1.203 + err = fbuf.Write(0, _L8(""));
1.204 + TEST2(err, KErrNone);
1.205 + TEST2(fbuf.iFileWriteCount, 0);
1.206 + TEST2(fbuf.iFileWriteAmount, 0);
1.207 + TEST2(fbuf.iFileSizeCount, 0);
1.208 +
1.209 + //First write operation. After the operation the file buffer must countain 10 bytes.
1.210 + err = fbuf.Write(0, _L8("A123456789"));
1.211 + TEST2(err, KErrNone);
1.212 + TEST2(fbuf.iFileWriteCount, 0);
1.213 + TEST2(fbuf.iFileWriteAmount, 0);
1.214 + TEST2(fbuf.iFileSizeCount, 1);
1.215 +
1.216 + //Second write operation. The offset is at the middle of the buffer. Data length: 10;
1.217 + err = fbuf.Write(5, _L8("ZZZZZEEEEE"));
1.218 + TEST2(err, KErrNone);
1.219 + TEST2(fbuf.iFileWriteCount, 0);
1.220 + TEST2(fbuf.iFileWriteAmount, 0);
1.221 +
1.222 + //Third write operation. The offset is at the end of the buffer. Data length: 5;
1.223 + err = fbuf.Write(15, _L8("CCCCC"));
1.224 + TEST2(err, KErrNone);
1.225 + TEST2(fbuf.iFileWriteCount, 0);
1.226 + TEST2(fbuf.iFileWriteAmount, 0);
1.227 +
1.228 + err = fbuf.Flush();
1.229 + TEST2(err, KErrNone);
1.230 + TEST2(fbuf.iFileWriteCount, 1);
1.231 + TEST2(fbuf.iFileFlushCount, 1);
1.232 + TEST2(fbuf.iFileWriteAmount, 20);
1.233 + TEST2(fbuf.iFileSizeCount, 1);
1.234 +
1.235 + fbuf.Close();
1.236 +
1.237 + VerifyFileContent(_L8("A1234ZZZZZEEEEECCCCC"));
1.238 +
1.239 + (void)TheFs.Delete(KTestFile);
1.240 + }
1.241 +
1.242 +/**
1.243 +@SYMTestCaseID PDS-SQL-UT-4133
1.244 +@SYMTestCaseDesc RFileBuf64 write test 2.
1.245 + The test performs file write operations using RFileBuf64 class.
1.246 + The write positions are beyound the end of the file but within the buffer capacity.
1.247 + The purpose of the test: to verify the logic of RFileBuf64::Write().
1.248 +@SYMTestActions RFileBuf64 write test 2.
1.249 +@SYMTestExpectedResults Test must not fail
1.250 +@SYMTestPriority High
1.251 +@SYMREQ REQ12106
1.252 + REQ12109
1.253 +*/
1.254 +void WriteTest2()
1.255 + {
1.256 + RFileBuf64 fbuf(1024);
1.257 + TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
1.258 + TEST2(err, KErrNone);
1.259 + fbuf.ProfilerReset();
1.260 +
1.261 + //First write operation. After the operation the file buffer must countain 10 bytes.
1.262 + err = fbuf.Write(0, _L8("A123456789"));
1.263 + TEST2(err, KErrNone);
1.264 + TEST2(fbuf.iFileWriteCount, 0);
1.265 + TEST2(fbuf.iFileWriteAmount, 0);
1.266 + TEST2(fbuf.iFileSizeCount, 1);
1.267 +
1.268 + //Second write operation. After the operation the file buffer must countain 10 + 10 zeros + 10 bytes.
1.269 + err = fbuf.Write(20, _L8("FFGGHHJJKK"));
1.270 + TEST2(err, KErrNone);
1.271 + TEST2(fbuf.iFileWriteCount, 0);
1.272 + TEST2(fbuf.iFileWriteAmount, 0);
1.273 + TEST2(fbuf.iFileSizeCount, 1);
1.274 +
1.275 + err = fbuf.Flush();
1.276 + TEST2(err, KErrNone);
1.277 + TEST2(fbuf.iFileWriteCount, 1);
1.278 + TEST2(fbuf.iFileFlushCount, 1);
1.279 + TEST2(fbuf.iFileWriteAmount, 30);
1.280 + TEST2(fbuf.iFileSizeCount, 1);
1.281 +
1.282 + fbuf.Close();
1.283 +
1.284 + TBuf8<30> pattern;
1.285 + pattern.Append(_L8("A123456789"));
1.286 + pattern.AppendFill(TChar(0), 10);
1.287 + pattern.Append(_L8("FFGGHHJJKK"));
1.288 + VerifyFileContent(pattern);
1.289 +
1.290 + (void)TheFs.Delete(KTestFile);
1.291 + }
1.292 +
1.293 +/**
1.294 +@SYMTestCaseID PDS-SQL-UT-4134
1.295 +@SYMTestCaseDesc RFileBuf64 write test 3.
1.296 + The test performs file write operations using RFileBuf64 class.
1.297 + The write position is before the start of the buffer but there is room for move.
1.298 + The purpose of the test: to verify the logic of RFileBuf64::Write().
1.299 +@SYMTestActions RFileBuf64 write test 3.
1.300 +@SYMTestExpectedResults Test must not fail
1.301 +@SYMTestPriority High
1.302 +@SYMREQ REQ12106
1.303 + REQ12109
1.304 +*/
1.305 +void WriteTest3()
1.306 + {
1.307 + //Iteration 1: The file length is 0, the first operation is "write beyond the end"
1.308 + //Iteration 2: The file length is 30, the first write operation is within the file.
1.309 + for(TInt i=0;i<2;++i)
1.310 + {
1.311 + RFileBuf64 fbuf(1024);
1.312 + TInt err = i == 0 ? fbuf.Create(TheFs, KTestFile, EFileWrite) : fbuf.Open(TheFs, KTestFile, EFileWrite);
1.313 + TEST2(err, KErrNone);
1.314 + fbuf.ProfilerReset();
1.315 +
1.316 + //First write operation. The offset is not 0. Data length: 10;
1.317 + err = fbuf.Write(20, _L8("A123456789"));
1.318 + TEST2(err, KErrNone);
1.319 + TEST2(fbuf.iFileWriteCount, 0);
1.320 + TEST2(fbuf.iFileWriteAmount, 0);
1.321 + TEST2(fbuf.iFileSizeCount, 1);
1.322 +
1.323 + //Second write operation. The offset is 0. Data length: 20;
1.324 + err = fbuf.Write(0, _L8("AASSDDFFRR**********"));
1.325 + TEST2(err, KErrNone);
1.326 + TEST2(fbuf.iFileWriteCount, 0);
1.327 + TEST2(fbuf.iFileWriteAmount, 0);
1.328 + TEST2(fbuf.iFileSizeCount, 1);
1.329 +
1.330 + err = fbuf.Flush();
1.331 + TEST2(err, KErrNone);
1.332 + TEST2(fbuf.iFileWriteCount, 1);
1.333 + TEST2(fbuf.iFileFlushCount, 1);
1.334 + TEST2(fbuf.iFileWriteAmount, 30);
1.335 + TEST2(fbuf.iFileSizeCount, 1);
1.336 +
1.337 + fbuf.Close();
1.338 +
1.339 + VerifyFileContent(_L8("AASSDDFFRR**********A123456789"));
1.340 + }
1.341 + (void)TheFs.Delete(KTestFile);
1.342 + }
1.343 +
1.344 +/**
1.345 +@SYMTestCaseID PDS-SQL-UT-4135
1.346 +@SYMTestCaseDesc RFileBuf64 write test 4.
1.347 + The test performs file write operations using RFileBuf64 class and verifies that
1.348 + that the pending write data will be stored in the file when the buffer is closed.
1.349 + The purpose of the test: to verify the logic of RFileBuf64::Write().
1.350 +@SYMTestActions RFileBuf64 write test 4.
1.351 +@SYMTestExpectedResults Test must not fail
1.352 +@SYMTestPriority High
1.353 +@SYMREQ REQ12106
1.354 + REQ12109
1.355 +*/
1.356 +void WriteTest4()
1.357 + {
1.358 + RFileBuf64 fbuf(1024);
1.359 + TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
1.360 + TEST2(err, KErrNone);
1.361 + fbuf.ProfilerReset();
1.362 +
1.363 + // Data length: 10;
1.364 + err = fbuf.Write(0, _L8("A123456789"));
1.365 + TEST2(err, KErrNone);
1.366 + TEST2(fbuf.iFileWriteCount, 0);
1.367 + TEST2(fbuf.iFileWriteAmount, 0);
1.368 + TEST2(fbuf.iFileSizeCount, 1);
1.369 +
1.370 + // Data length: 0;
1.371 + err = fbuf.Write(10, _L8(""));
1.372 + TEST2(err, KErrNone);
1.373 + TEST2(fbuf.iFileWriteCount, 0);
1.374 + TEST2(fbuf.iFileWriteAmount, 0);
1.375 + TEST2(fbuf.iFileSizeCount, 1);
1.376 +
1.377 + fbuf.Close();
1.378 +
1.379 + VerifyFileContent(_L8("A123456789"));
1.380 +
1.381 + (void)TheFs.Delete(KTestFile);
1.382 + }
1.383 +
1.384 +/**
1.385 +@SYMTestCaseID PDS-SQL-UT-4136
1.386 +@SYMTestCaseDesc RFileBuf64 write test 5.
1.387 + The test performs file write operations using RFileBuf64 class.
1.388 + The data is written before the start of the file buffer and is too big to fit in the buffer.
1.389 + The purpose of the test: to verify the logic of RFileBuf64::Write().
1.390 +@SYMTestActions RFileBuf64 write test 5.
1.391 +@SYMTestExpectedResults Test must not fail
1.392 +@SYMTestPriority High
1.393 +@SYMREQ REQ12106
1.394 + REQ12109
1.395 +*/
1.396 +void WriteTest5()
1.397 + {
1.398 + RFileBuf64 fbuf(20);
1.399 + TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
1.400 + TEST2(err, KErrNone);
1.401 + fbuf.ProfilerReset();
1.402 +
1.403 + //First write operation. The offset is not 0. Data length: 10;
1.404 + err = fbuf.Write(10, _L8("A123456789"));
1.405 + TEST2(err, KErrNone);
1.406 + TEST2(fbuf.iFileWriteCount, 0);
1.407 + TEST2(fbuf.iFileWriteAmount, 0);
1.408 + TEST2(fbuf.iFileSizeCount, 1);
1.409 +
1.410 + //Second write operation. The offset is 0. Data length: 12, i.e. within the buffer - should have no write to the disk.
1.411 + err = fbuf.Write(0, _L8("ZZXXCCVVBBNN"));
1.412 + TEST2(err, KErrNone);
1.413 + TEST2(fbuf.iFileWriteCount, 0);
1.414 + TEST2(fbuf.iFileWriteAmount, 0);
1.415 + TEST2(fbuf.iFileSizeCount, 1);
1.416 +
1.417 + //Third write operation. The offet is 18. Data length: 5. The buffer should be written out to the file
1.418 + // after "ab" is appended to the buffer. The new buffe after being emptied should have data "cde".
1.419 + err = fbuf.Write(18, _L8("abcde"));
1.420 + TEST2(err, KErrNone);
1.421 + TEST2(fbuf.iFileWriteCount, 1);
1.422 + TEST2(fbuf.iFileWriteAmount, 20);
1.423 + TEST2(fbuf.iFileSizeCount, 1);
1.424 +
1.425 + err = fbuf.Flush();
1.426 + TEST2(err, KErrNone);
1.427 + TEST2(fbuf.iFileWriteCount, 2);
1.428 + TEST2(fbuf.iFileFlushCount, 1);
1.429 + TEST2(fbuf.iFileWriteAmount, 23);
1.430 + TEST2(fbuf.iFileSizeCount, 1);
1.431 +
1.432 + fbuf.Close();
1.433 +
1.434 + VerifyFileContent(_L8("ZZXXCCVVBBNN234567abcde"));
1.435 +
1.436 + (void)TheFs.Delete(KTestFile);
1.437 + }
1.438 +
1.439 +/**
1.440 +@SYMTestCaseID PDS-SQL-UT-4137
1.441 +@SYMTestCaseDesc RFileBuf64 write test 6.
1.442 + The test performs file write operations using RFileBuf64 class.
1.443 + The data is written before the start of the file buffer and is too big to fit in the buffer.
1.444 + The purpose of the test: to verify the logic of RFileBuf64::Write().
1.445 +@SYMTestActions RFileBuf64 write test 6.
1.446 +@SYMTestExpectedResults Test must not fail
1.447 +@SYMTestPriority High
1.448 +@SYMREQ REQ12106
1.449 + REQ12109
1.450 +*/
1.451 +void WriteTest6()
1.452 + {
1.453 + RFileBuf64 fbuf(20);
1.454 + TInt err = fbuf.Create(TheFs, KTestFile, EFileWrite);
1.455 + TEST2(err, KErrNone);
1.456 +
1.457 + err = fbuf.Write(0, _L8("A123456789B123456789C123456789"));
1.458 + TEST2(err, KErrNone);
1.459 + err = fbuf.Flush();
1.460 + TEST2(err, KErrNone);
1.461 + fbuf.Close();
1.462 + VerifyFileContent(_L8("A123456789B123456789C123456789"));
1.463 +
1.464 + err = fbuf.Open(TheFs, KTestFile, EFileWrite);
1.465 + TEST2(err, KErrNone);
1.466 + fbuf.ProfilerReset();
1.467 +
1.468 + //First write operation. The offset is not 0. Data length: 10;
1.469 + err = fbuf.Write(15, _L8("OOOOOOOOOO"));
1.470 + TEST2(err, KErrNone);
1.471 + TEST2(fbuf.iFileWriteCount, 0);
1.472 + TEST2(fbuf.iFileWriteAmount, 0);
1.473 + TEST2(fbuf.iFileSizeCount, 1);
1.474 +
1.475 + //Second write operation. The offset is 0. Data length: 15;
1.476 + err = fbuf.Write(0, _L8("TTTTTTTTTTTTTTT"));
1.477 + TEST2(err, KErrNone);
1.478 + TEST2(fbuf.iFileWriteCount, 1);
1.479 + TEST2(fbuf.iFileWriteAmount, 10);
1.480 + TEST2(fbuf.iFileSizeCount, 1);
1.481 +
1.482 + err = fbuf.Flush();
1.483 + TEST2(err, KErrNone);
1.484 + TEST2(fbuf.iFileWriteCount, 2);
1.485 + TEST2(fbuf.iFileFlushCount, 1);
1.486 + TEST2(fbuf.iFileWriteAmount, 15 + 10);
1.487 + TEST2(fbuf.iFileSizeCount, 1);
1.488 +
1.489 + fbuf.Close();
1.490 +
1.491 + VerifyFileContent(_L8("TTTTTTTTTTTTTTTOOOOOOOOOO56789"));
1.492 +
1.493 + (void)TheFs.Delete(KTestFile);
1.494 + }
1.495 +
1.496 +void PrepareReadTest()
1.497 + {
1.498 + RFile64 file;
1.499 + TInt err = file.Create(TheFs, KTestFile, EFileWrite);
1.500 + TEST2(err, KErrNone);
1.501 + err = file.Write(_L8("A123456789ZZZZZZZZZZB-B-B-B-B-Y*Y*Y*Y*Y*"));
1.502 + TEST2(err, KErrNone);
1.503 + err = file.Flush();
1.504 + TEST2(err, KErrNone);
1.505 + file.Close();
1.506 + }
1.507 +
1.508 +/**
1.509 +@SYMTestCaseID PDS-SQL-UT-4138
1.510 +@SYMTestCaseDesc RFileBuf64 read test 1.
1.511 + The test performs file read operations using RFileBuf64 class.
1.512 + Tested "read" operations:
1.513 + - Zero max length request;
1.514 + - Too big read request;
1.515 + - Read beyond the end of the file;
1.516 + The purpose of the test: to verify the logic of RFileBuf64::Read().
1.517 +@SYMTestActions RFileBuf64 read test 1.
1.518 +@SYMTestExpectedResults Test must not fail
1.519 +@SYMTestPriority High
1.520 +@SYMREQ REQ12106
1.521 + REQ12109
1.522 +*/
1.523 +void ReadTest1()
1.524 + {
1.525 + const TInt KBufMaxSize = 20;// This is half the file size
1.526 + RFileBuf64 fbuf(KBufMaxSize);
1.527 + TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead | EFileShareReadersOrWriters);
1.528 + TEST2(err, KErrNone);
1.529 + fbuf.ProfilerReset();
1.530 +
1.531 + //Zero max length request
1.532 + TUint8 buf1[1];
1.533 + TPtr8 ptr1(buf1, 0);
1.534 + err = fbuf.Read(0, ptr1);
1.535 + TEST2(err, KErrNone);
1.536 + TEST2(fbuf.iFileReadCount, 0);
1.537 + TEST2(fbuf.iFileReadAmount, 0);
1.538 + TEST2(fbuf.iFileSizeCount, 0);
1.539 +
1.540 + //Too big request
1.541 + TBuf8<KBufMaxSize * 2> buf2;
1.542 + err = fbuf.Read(0, buf2);
1.543 + TEST2(err, KErrNone);
1.544 + TEST2(fbuf.iFileReadCount, 1);
1.545 + TEST2(fbuf.iFileReadAmount, (KBufMaxSize * 2));
1.546 + TEST2(fbuf.iFileSizeCount, 1);
1.547 + VerifyFileContent(buf2);
1.548 +
1.549 + //Read beyond the end of the file
1.550 + err = fbuf.Read(2000, buf2);
1.551 + TEST2(err, KErrNone);
1.552 + TEST2(buf2.Length(), 0);
1.553 +
1.554 + //Write "5678" in the buffer, pos [4..8)
1.555 + err = fbuf.Write(4, _L8("5678"));
1.556 + TEST2(err, KErrNone);
1.557 +
1.558 + //Too big request. There are pending data in the buffer.
1.559 + TBuf8<KBufMaxSize + 2> buf3;
1.560 + err = fbuf.Read(1, buf3);
1.561 + TEST2(err, KErrNone);
1.562 + VerifyFileContent(buf3, 1);
1.563 +
1.564 + //Read from a non-zero file position to move the buffer start pos. The cached file pos will be 35 at the end.
1.565 + TBuf8<5> buf4;
1.566 + err = fbuf.Read(30, buf4);
1.567 + TEST2(err, KErrNone);
1.568 + VerifyFileContent(buf4, 30);
1.569 + err = fbuf.Read(35, buf4);
1.570 + TEST2(err, KErrNone);
1.571 + VerifyFileContent(buf4, 35);
1.572 +
1.573 + //Too big request. No pending data in the buffer. The file read pos is before the position of the cached data in the buffer.
1.574 + err = fbuf.Read(10, buf3);
1.575 + TEST2(err, KErrNone);
1.576 + VerifyFileContent(buf3, 10);
1.577 +
1.578 + fbuf.Close();
1.579 + }
1.580 +
1.581 +/**
1.582 +@SYMTestCaseID PDS-SQL-UT-4139
1.583 +@SYMTestCaseDesc RFileBuf64 read test 2.
1.584 + The test performs file read operations using RFileBuf64 class.
1.585 + Tested operations:
1.586 + - Non-buffered reads;
1.587 + - Buffered reads;
1.588 + The purpose of the test: to verify the logic of RFileBuf64::Read().
1.589 +@SYMTestActions RFileBuf64 read test 2.
1.590 +@SYMTestExpectedResults Test must not fail
1.591 +@SYMTestPriority High
1.592 +@SYMREQ REQ12106
1.593 + REQ12109
1.594 +*/
1.595 +void ReadTest2()
1.596 + {
1.597 + RFileBuf64 fbuf(1024);
1.598 + TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead | EFileShareReadersOrWriters);
1.599 + TEST2(err, KErrNone);
1.600 + fbuf.ProfilerReset();
1.601 +
1.602 + //1. Read bytes [0..20]
1.603 + TBuf8<20> buf1;
1.604 + err = fbuf.Read(0, buf1);
1.605 + TEST2(err, KErrNone);
1.606 + TEST2(fbuf.iFileReadCount, 1);
1.607 + TEST2(fbuf.iFileReadAmount, 20);
1.608 + TEST2(fbuf.iFileSizeCount, 1);
1.609 + fbuf.ProfilerReset();
1.610 + VerifyFileContent(buf1, 0);
1.611 +
1.612 + //2. Read again, bytes [10..20]. They are not buffered.
1.613 + TBuf8<10> buf2;
1.614 + err = fbuf.Read(10, buf2);
1.615 + TEST2(err, KErrNone);
1.616 + TEST2(fbuf.iFileReadCount, 1);
1.617 + TEST2(fbuf.iFileReadAmount, 10);
1.618 + TEST2(fbuf.iFileSizeCount, 0);
1.619 + fbuf.ProfilerReset();
1.620 + VerifyFileContent(buf2, 10);
1.621 +
1.622 + //3. Read again, bytes [20..30]. They are not buffered. But the file buffer will be populated,
1.623 + // because the file read position matches the guessed file read position from step 2.
1.624 + err = fbuf.Read(20, buf2);
1.625 + TEST2(err, KErrNone);
1.626 + TEST2(fbuf.iFileReadCount, 1);
1.627 + TEST2(fbuf.iFileReadAmount, (10 * 2));
1.628 + TEST2(fbuf.iFileSizeCount, 0);
1.629 + fbuf.ProfilerReset();
1.630 + VerifyFileContent(buf2, 20);
1.631 +
1.632 + //4. Read again, bytes [25..35]. This is a buffered read operation.
1.633 + err = fbuf.Read(25, buf2);
1.634 + TEST2(err, KErrNone);
1.635 + TEST2(fbuf.iFileReadCount, 0);
1.636 + TEST2(fbuf.iFileReadAmount, 0);
1.637 + TEST2(fbuf.iFileSizeCount, 0);
1.638 + fbuf.ProfilerReset();
1.639 + VerifyFileContent(buf2, 25);
1.640 +
1.641 + //5. Read again, bytes [15..25]. This is a non buffered read operation.
1.642 + err = fbuf.Read(15, buf2);
1.643 + TEST2(err, KErrNone);
1.644 + TEST2(fbuf.iFileReadCount, 1);
1.645 + TEST2(fbuf.iFileReadAmount, 10);
1.646 + TEST2(fbuf.iFileSizeCount, 0);
1.647 + fbuf.ProfilerReset();
1.648 + VerifyFileContent(buf2, 15);
1.649 +
1.650 + //6. Read again, bytes [25..35]. This is a buffered read operation. The buffer from step 3 is still there.
1.651 + err = fbuf.Read(25, buf2);
1.652 + TEST2(err, KErrNone);
1.653 + TEST2(fbuf.iFileReadCount, 0);
1.654 + TEST2(fbuf.iFileReadAmount, 0);
1.655 + TEST2(fbuf.iFileSizeCount, 0);
1.656 + fbuf.ProfilerReset();
1.657 + VerifyFileContent(buf2, 25);
1.658 +
1.659 + //7. Read again, bytes [35..45] - beyond the end of the file.
1.660 + // This is a buffered read operation. The buffer from step 3 is still there.
1.661 + err = fbuf.Read(35, buf2);
1.662 + TEST2(err, KErrNone);
1.663 + TEST2(fbuf.iFileReadCount, 0);
1.664 + TEST2(fbuf.iFileReadAmount, 0);
1.665 + TEST2(fbuf.iFileSizeCount, 0);
1.666 + TEST2(buf2.Size(), 5);
1.667 + fbuf.ProfilerReset();
1.668 + VerifyFileContent(buf2, 35);
1.669 +
1.670 + fbuf.Close();
1.671 + }
1.672 +
1.673 +/**
1.674 +@SYMTestCaseID PDS-SQL-UT-4140
1.675 +@SYMTestCaseDesc RFileBuf64 read test 3.
1.676 + The test performs file read operations using RFileBuf64 class.
1.677 + Tested operations:
1.678 + - Non-buffered reads;
1.679 + - Buffered reads;
1.680 + - Part- buffered reads;
1.681 + The purpose of the test: to verify the logic of RFileBuf64::Read().
1.682 +@SYMTestActions RFileBuf64 read test 3.
1.683 +@SYMTestExpectedResults Test must not fail
1.684 +@SYMTestPriority High
1.685 +@SYMREQ REQ12106
1.686 + REQ12109
1.687 +*/
1.688 +void ReadTest3()
1.689 + {
1.690 + RFileBuf64 fbuf(1024);
1.691 + TInt err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead | EFileShareReadersOrWriters);
1.692 + TEST2(err, KErrNone);
1.693 + fbuf.ProfilerReset();
1.694 +
1.695 + //1. Read bytes [0..10]. Non buffered.
1.696 + TBuf8<10> buf1;
1.697 + err = fbuf.Read(0, buf1);
1.698 + TEST2(err, KErrNone);
1.699 + TEST2(fbuf.iFileReadCount, 1);
1.700 + TEST2(fbuf.iFileReadAmount, 10);
1.701 + TEST2(fbuf.iFileSizeCount, 1);
1.702 + fbuf.ProfilerReset();
1.703 + VerifyFileContent(buf1, 0);
1.704 +
1.705 + //2. Read bytes [10..20]. Non buffered. But the file buffer is populated, bytes [10..40].
1.706 + err = fbuf.Read(10, buf1);
1.707 + TEST2(err, KErrNone);
1.708 + TEST2(fbuf.iFileReadCount, 1);
1.709 + TEST2(fbuf.iFileReadAmount, 30);
1.710 + TEST2(fbuf.iFileSizeCount, 0);
1.711 + fbuf.ProfilerReset();
1.712 + VerifyFileContent(buf1, 10);
1.713 +
1.714 + //3. Read bytes [25..35]. Buffered. Because the previous operation [2] performed a read-ahead operation.
1.715 + err = fbuf.Read(25, buf1);
1.716 + TEST2(err, KErrNone);
1.717 + TEST2(fbuf.iFileReadCount, 0);
1.718 + TEST2(fbuf.iFileReadAmount, 0);
1.719 + TEST2(fbuf.iFileSizeCount, 0);
1.720 + fbuf.ProfilerReset();
1.721 + VerifyFileContent(buf1, 25);
1.722 +
1.723 + //4. Write bytes [20..30]. Buffered. Read buffer is gone, the file buffer contains the [20..30] file area.
1.724 + err = fbuf.Write(20, _L8("IIIIIQQQQQ"));
1.725 + TEST2(err, KErrNone);
1.726 + TEST2(fbuf.iFileReadCount, 0);
1.727 + TEST2(fbuf.iFileReadAmount, 0);
1.728 + TEST2(fbuf.iFileWriteCount, 0);
1.729 + TEST2(fbuf.iFileWriteAmount, 0);
1.730 + TEST2(fbuf.iFileSizeCount, 0);
1.731 + fbuf.ProfilerReset();
1.732 +
1.733 + //5. Read bytes [25..35]. Part-buffered. Part of pending writes picked up. Then the buffer is flushed.
1.734 + err = fbuf.Read(25, buf1);
1.735 + TEST2(err, KErrNone);
1.736 + TEST2(fbuf.iFileReadCount, 1);
1.737 + TEST2(fbuf.iFileReadAmount, 5);
1.738 + TEST2(fbuf.iFileWriteCount, 1);
1.739 + TEST2(fbuf.iFileWriteAmount, 10);
1.740 + TEST2(fbuf.iFileSizeCount, 0);
1.741 +
1.742 + fbuf.ProfilerReset();
1.743 + err = fbuf.Flush();
1.744 + TEST2(err, KErrNone);
1.745 +
1.746 + //All cached data should have been written to the file before the Flush() call.
1.747 + TEST2(fbuf.iFileReadCount, 0);
1.748 + TEST2(fbuf.iFileReadAmount, 0);
1.749 + TEST2(fbuf.iFileWriteCount, 0);
1.750 + TEST2(fbuf.iFileWriteAmount, 0);
1.751 + TEST2(fbuf.iFileSizeCount, 0);
1.752 + TEST2(fbuf.iFileFlushCount, 1);
1.753 +
1.754 + fbuf.ProfilerReset();
1.755 + VerifyFileContent(buf1, 25);
1.756 +
1.757 + //6. The buffer is empty after the last flush. Write bytes [0..10]. The file buffer contains the [0..10] file area.
1.758 + err = fbuf.Write(0, _L8("PPOOIIUUYY"));
1.759 + TEST2(err, KErrNone);
1.760 + TEST2(fbuf.iFileReadCount, 0);
1.761 + TEST2(fbuf.iFileReadAmount, 0);
1.762 + TEST2(fbuf.iFileWriteCount, 0);
1.763 + TEST2(fbuf.iFileWriteAmount, 0);
1.764 + TEST2(fbuf.iFileSizeCount, 0);
1.765 + fbuf.ProfilerReset();
1.766 +
1.767 + //7. Read bytes [5..15]. Part buffered. Pending writes picked up. The content is written to the file.
1.768 + err = fbuf.Read(5, buf1);
1.769 + TEST2(err, KErrNone);
1.770 + TEST2(fbuf.iFileReadCount, 1);
1.771 + TEST2(fbuf.iFileReadAmount, 5);
1.772 + TEST2(fbuf.iFileWriteCount, 1);
1.773 + TEST2(fbuf.iFileWriteAmount, 10);
1.774 + TEST2(fbuf.iFileSizeCount, 0);
1.775 + fbuf.ProfilerReset();
1.776 + VerifyFileContent(buf1, 5);
1.777 +
1.778 + fbuf.Close();
1.779 + }
1.780 +
1.781 +/**
1.782 +@SYMTestCaseID PDS-SQL-UT-4141
1.783 +@SYMTestCaseDesc RFileBuf64::SetReadAheadSize() test.
1.784 + The test iterates over all existing drives.
1.785 + For each R/W drive a test file is created using RFileBuf64 class.
1.786 + Then the test collects information regarding the block size, cluster size and
1.787 + read buffer size and calls RFileBuf64::SetReadAheadSize() with these parameters
1.788 + to check how the read-ahead buffer size will be recalculated.
1.789 +@SYMTestActions RFileBuf64::SetReadAheadSize() test.
1.790 +@SYMTestExpectedResults Test must not fail
1.791 +@SYMTestPriority High
1.792 +@SYMREQ REQ12106
1.793 + REQ12109
1.794 +*/
1.795 +void SetReadAheadSizeTest()
1.796 + {
1.797 + TheTest.Printf(_L("==================\r\n"));
1.798 + _LIT(KType1, "Not present");
1.799 + _LIT(KType2, "Unknown");
1.800 + _LIT(KType3, "Floppy");
1.801 + _LIT(KType4, "Hard disk");
1.802 + _LIT(KType5, "CD ROM");
1.803 + _LIT(KType6, "RAM disk");
1.804 + _LIT(KType7, "Flash");
1.805 + _LIT(KType8, "ROM drive");
1.806 + _LIT(KType9, "Remote drive");
1.807 + _LIT(KType10,"NAND flash");
1.808 + _LIT(KType11,"Rotating media");
1.809 +
1.810 + for(TInt drive=EDriveA;drive<=EDriveZ;++drive)
1.811 + {
1.812 + TDriveInfo driveInfo;
1.813 + TInt err = TheFs.Drive(driveInfo, drive);
1.814 + if(err == KErrNone)
1.815 + {
1.816 + TVolumeInfo vinfo;
1.817 + err = TheFs.Volume(vinfo, drive);
1.818 + if(err == KErrNone)
1.819 + {
1.820 + TVolumeIOParamInfo vparam;
1.821 + err = TheFs.VolumeIOParam(drive, vparam);
1.822 + TEST2(err, KErrNone);
1.823 + TBuf8<128> vinfoex8;
1.824 + err = TheFs.QueryVolumeInfoExt(drive, EFileSystemSubType, vinfoex8);
1.825 + TEST2(err, KErrNone);
1.826 + TPtrC vinfoex((const TUint16*)(vinfoex8.Ptr() + 8), vinfoex8[0]);
1.827 + TPtrC KMediaTypeNames[] = {KType1(), KType2(), KType3(), KType4(), KType5(), KType6(), KType7(), KType8(), KType9(), KType10(), KType11()};
1.828 + 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)));
1.829 + TheTest.Printf(_L(" Size: %ld bytes.\r\n"), vinfo.iSize);
1.830 + TheTest.Printf(_L(" Block size=%d, Cluster size=%d, Read buffer size=%d.\r\n"), vparam.iBlockSize, vparam.iClusterSize, vparam.iRecReadBufSize);
1.831 + if(driveInfo.iType == EMediaRam || driveInfo.iType == EMediaHardDisk || driveInfo.iType == EMediaFlash || driveInfo.iType == EMediaNANDFlash)
1.832 + {
1.833 + TDriveUnit drvUnit(drive);
1.834 + TDriveName drvName = drvUnit.Name();
1.835 + TParse parse;
1.836 + parse.Set(KTestFile2, &drvName, NULL);
1.837 + TheDbName.Copy(parse.FullName());
1.838 + TRAP(err, BaflUtils::EnsurePathExistsL(TheFs, TheDbName));
1.839 + if(err == KErrNone || err == KErrAlreadyExists)
1.840 + {
1.841 + (void)TheFs.Delete(TheDbName);
1.842 + RFileBuf64 fbuf64(8 * 1024);
1.843 + err = fbuf64.Create(TheFs, TheDbName, EFileRead | EFileWrite);
1.844 + TEST2(err, KErrNone);
1.845 + TInt readAhead = fbuf64.SetReadAheadSize(vparam.iBlockSize, vparam.iRecReadBufSize);
1.846 + TheTest.Printf(_L(" Read-ahead size=%d.\r\n"), readAhead);
1.847 + fbuf64.Close();
1.848 + (void)TheFs.Delete(TheDbName);
1.849 + }
1.850 + else
1.851 + {
1.852 + TheTest.Printf(_L("Drive %C. BaflUtils::EnsurePathExistsL() has failed with err=%d.\r\n"), 'A' + drive, err);
1.853 + }
1.854 + }
1.855 + }
1.856 + else
1.857 + {
1.858 + TheTest.Printf(_L("Drive %C. RFs::Volume() has failed with err=%d.\r\n"), 'A' + drive, err);
1.859 + }
1.860 + }
1.861 + else
1.862 + {
1.863 + TheTest.Printf(_L("Drive %C. RFs::Drive() has failed with err=%d.\r\n"), 'A' + drive, err);
1.864 + }
1.865 + }
1.866 + TheTest.Printf(_L("==================\r\n"));
1.867 + //
1.868 + RFileBuf64 fbuf64(8 * 1024);//buffer capacity = 8Kb
1.869 +
1.870 + //"ReadRecBufSize" defined and is power of two, the "BlockSize" is also defined and is power of two
1.871 + TInt err2 = fbuf64.Create(TheFs, TheDbName, EFileRead | EFileWrite);
1.872 + TEST2(err2, KErrNone);
1.873 + TInt blockSize = 4096; TInt readRecBufSize = 2048;
1.874 + TInt readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
1.875 + TEST2(readAhead2, readRecBufSize);
1.876 + fbuf64.Close();
1.877 +
1.878 + //"ReadRecBufSize" defined and is power of two but is less than the default read-ahead value
1.879 + err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
1.880 + TEST2(err2, KErrNone);
1.881 + blockSize = 0; readRecBufSize = 128;
1.882 + readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
1.883 + TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
1.884 + fbuf64.Close();
1.885 +
1.886 + //"ReadRecBufSize" defined and is power of two but is bigger than the buffer capacity
1.887 + err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
1.888 + TEST2(err2, KErrNone);
1.889 + blockSize = -10; readRecBufSize = fbuf64.iCapacity * 2;
1.890 + readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
1.891 + TEST2(readAhead2, fbuf64.iCapacity);
1.892 + fbuf64.Close();
1.893 +
1.894 + //"ReadRecBufSize" defined but is not power of two, "BlockSize" defined but is less than the default read-ahead value
1.895 + err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
1.896 + TEST2(err2, KErrNone);
1.897 + blockSize = 512; readRecBufSize = 4000;
1.898 + readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
1.899 + TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
1.900 + fbuf64.Close();
1.901 +
1.902 + //"ReadRecBufSize" defined but is not power of two, "BlockSize" defined and is bigger than the default read-ahead value
1.903 + err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
1.904 + TEST2(err2, KErrNone);
1.905 + blockSize = 4096; readRecBufSize = 4000;
1.906 + readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
1.907 + TEST2(readAhead2, blockSize);
1.908 + fbuf64.Close();
1.909 +
1.910 + //"ReadRecBufSize" defined but is not power of two, "BlockSize" defined and is bigger than the buffer capacity
1.911 + err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
1.912 + TEST2(err2, KErrNone);
1.913 + blockSize = fbuf64.iCapacity * 2; readRecBufSize = 1;
1.914 + readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
1.915 + TEST2(readAhead2, fbuf64.iCapacity);
1.916 + fbuf64.Close();
1.917 +
1.918 + //"ReadRecBufSize" negative, "BlockSize" defined but is not power of two
1.919 + err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
1.920 + TEST2(err2, KErrNone);
1.921 + blockSize = 1000; readRecBufSize = -2;
1.922 + readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
1.923 + TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
1.924 + fbuf64.Close();
1.925 +
1.926 + //"ReadRecBufSize" negative, "BlockSize" negative
1.927 + err2 = fbuf64.Open(TheFs, TheDbName, EFileRead | EFileWrite);
1.928 + TEST2(err2, KErrNone);
1.929 + blockSize = -1; readRecBufSize = -2;
1.930 + readAhead2 = fbuf64.SetReadAheadSize(blockSize, readRecBufSize);
1.931 + TEST2(readAhead2, RFileBuf64::KDefaultReadAheadSize);
1.932 + fbuf64.Close();
1.933 + //
1.934 + (void)TheFs.Delete(TheDbName);
1.935 + }
1.936 +
1.937 +/**
1.938 +@SYMTestCaseID PDS-SQL-UT-4142
1.939 +@SYMTestCaseDesc RFileBuf64 OOM test.
1.940 + The test calls RFileBuf64:Create(), RFileBuf64:Open() and RFileBuf64:Temp() in an OOM
1.941 + simulation loop and verifies that no memory is leaked.
1.942 +@SYMTestActions RFileBuf64 OOM test.
1.943 +@SYMTestExpectedResults Test must not fail
1.944 +@SYMTestPriority High
1.945 +@SYMREQ REQ12106
1.946 + REQ12109
1.947 +*/
1.948 +void OomTest(TOomTestType aOomTestType)
1.949 + {
1.950 + (void)TheFs.Delete(KTestFile);
1.951 +
1.952 + if(aOomTestType == EOomOpenTest)
1.953 + {
1.954 + RFile64 file;
1.955 + TInt err2 = file.Create(TheFs, KTestFile, EFileWrite | EFileRead);
1.956 + file.Close();
1.957 + TEST2(err2, KErrNone);
1.958 + }
1.959 +
1.960 + TFileName tmpFileName;
1.961 + TInt err = KErrNoMemory;
1.962 + TInt failingAllocationNo = 0;
1.963 + RFileBuf64 fbuf(1024);
1.964 + TheTest.Printf(_L("Iteration:\r\n"));
1.965 + while(err == KErrNoMemory)
1.966 + {
1.967 + TheTest.Printf(_L(" %d"), ++failingAllocationNo);
1.968 +
1.969 + MarkHandles();
1.970 + MarkAllocatedCells();
1.971 +
1.972 + __UHEAP_MARK;
1.973 + __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
1.974 +
1.975 + switch(aOomTestType)
1.976 + {
1.977 + case EOomCreateTest:
1.978 + err = fbuf.Create(TheFs, KTestFile, EFileWrite | EFileRead);
1.979 + break;
1.980 + case EOomOpenTest:
1.981 + err = fbuf.Open(TheFs, KTestFile, EFileWrite | EFileRead);
1.982 + break;
1.983 + case EOomTempTest:
1.984 + {
1.985 + err = fbuf.Temp(TheFs, KTestDir, tmpFileName, EFileWrite | EFileRead);
1.986 + }
1.987 + break;
1.988 + default:
1.989 + TEST(0);
1.990 + break;
1.991 + }
1.992 + fbuf.Close();
1.993 +
1.994 + __UHEAP_RESET;
1.995 + __UHEAP_MARKEND;
1.996 +
1.997 + CheckAllocatedCells();
1.998 + CheckHandles();
1.999 +
1.1000 + TEntry entry;
1.1001 + if(err != KErrNoMemory)
1.1002 + {
1.1003 + TEST2(err, KErrNone);
1.1004 + }
1.1005 + else if(aOomTestType == EOomCreateTest)
1.1006 + {
1.1007 + TInt err2 = TheFs.Entry(KTestFile, entry);
1.1008 + TEST2(err2, KErrNotFound);
1.1009 + }
1.1010 + else if(aOomTestType == EOomTempTest)
1.1011 + {
1.1012 + if(tmpFileName.Size() > 0)
1.1013 + {
1.1014 + TInt err2 = TheFs.Entry(tmpFileName, entry);
1.1015 + TEST2(err2, KErrNotFound);
1.1016 + }
1.1017 + }
1.1018 + }
1.1019 + TEST2(err, KErrNone);
1.1020 + TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
1.1021 +
1.1022 + if(aOomTestType == EOomTempTest)
1.1023 + {
1.1024 + (void)TheFs.Delete(tmpFileName);
1.1025 + }
1.1026 + (void)TheFs.Delete(KTestFile);
1.1027 + }
1.1028 +
1.1029 +/**
1.1030 +@SYMTestCaseID PDS-SQL-UT-4195
1.1031 +@SYMTestCaseDesc RFileBuf64::Create() file I/O error simulation test.
1.1032 + The test calls RFileBuf64:Create() in a file I/O error simulation loop.
1.1033 +@SYMTestActions RFileBuf64::Create() file I/O error simulation test.
1.1034 +@SYMTestExpectedResults Test must not fail
1.1035 +@SYMTestPriority High
1.1036 +@SYMDEF DEF145198
1.1037 +*/
1.1038 +void CreateFileIoErrTest()
1.1039 + {
1.1040 + TInt err = KErrGeneral;
1.1041 + TInt cnt = 0;
1.1042 + for(;err<KErrNone;++cnt)
1.1043 + {
1.1044 + TheTest.Printf(_L("===Iteration %d. Simulated error:\r\n"), cnt);
1.1045 + for (TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
1.1046 + {
1.1047 + TheTest.Printf(_L("%d "), fsError);
1.1048 + __UHEAP_MARK;
1.1049 + (void)TheFs.SetErrorCondition(fsError, cnt);
1.1050 + RFileBuf64 fbuf(1024);//buffer capacity = 1024 bytes
1.1051 + err = fbuf.Create(TheFs, KTestFile3, EFileRead | EFileWrite);
1.1052 + (void)TheFs.SetErrorCondition(KErrNone);
1.1053 + fbuf.Close();
1.1054 + __UHEAP_MARKEND;
1.1055 + TInt err2 = TheFs.Delete(KTestFile3);
1.1056 + TInt expectedErr = err == KErrNone ? KErrNone : KErrNotFound;
1.1057 + TEST2(err2, expectedErr);
1.1058 + }
1.1059 + TheTest.Printf(_L("\r\n"));
1.1060 + }
1.1061 + TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\n"), cnt);
1.1062 + }
1.1063 +
1.1064 +/**
1.1065 +@SYMTestCaseID PDS-SQL-UT-4196
1.1066 +@SYMTestCaseDesc RFileBuf64::Open() file I/O error simulation test.
1.1067 + The test calls RFileBuf64:Open() in a file I/O error simulation loop.
1.1068 +@SYMTestActions RFileBuf64::Open() file I/O error simulation test.
1.1069 +@SYMTestExpectedResults Test must not fail
1.1070 +@SYMTestPriority High
1.1071 +@SYMDEF DEF145198
1.1072 +*/
1.1073 +void OpenFileIoErrTest()
1.1074 + {
1.1075 + RFileBuf64 fbuf(1024);//buffer capacity = 1024 bytes
1.1076 + TInt err = fbuf.Create(TheFs, KTestFile3, EFileRead | EFileWrite);
1.1077 + fbuf.Close();
1.1078 + TEST2(err, KErrNone);
1.1079 + err = KErrGeneral;
1.1080 + TInt cnt = 0;
1.1081 + for(;err<KErrNone;++cnt)
1.1082 + {
1.1083 + TheTest.Printf(_L("===Iteration %d. Simulated error:\r\n"), cnt);
1.1084 + for (TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
1.1085 + {
1.1086 + TheTest.Printf(_L("%d "), fsError);
1.1087 + __UHEAP_MARK;
1.1088 + (void)TheFs.SetErrorCondition(fsError, cnt);
1.1089 + err = fbuf.Open(TheFs, KTestFile3, EFileRead | EFileWrite);
1.1090 + (void)TheFs.SetErrorCondition(KErrNone);
1.1091 + fbuf.Close();
1.1092 + __UHEAP_MARKEND;
1.1093 + }
1.1094 + TheTest.Printf(_L("\r\n"));
1.1095 + }
1.1096 + TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\n"), cnt);
1.1097 + (void)TheFs.Delete(KTestFile3);
1.1098 + }
1.1099 +
1.1100 +/**
1.1101 +@SYMTestCaseID PDS-SQL-UT-4197
1.1102 +@SYMTestCaseDesc RFileBuf64::Temp() file I/O error simulation test.
1.1103 + The test calls RFileBuf64:Temp() in a file I/O error simulation loop.
1.1104 +@SYMTestActions RFileBuf64::temp() file I/O error simulation test.
1.1105 +@SYMTestExpectedResults Test must not fail
1.1106 +@SYMTestPriority High
1.1107 +@SYMDEF DEF145198
1.1108 +*/
1.1109 +void TempFileIoErrTest()
1.1110 + {
1.1111 + TInt err = KErrGeneral;
1.1112 + TInt cnt = 0;
1.1113 + for(;err<KErrNone;++cnt)
1.1114 + {
1.1115 + TheTest.Printf(_L("===Iteration %d. Simulated error:\r\n"), cnt);
1.1116 + for (TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)
1.1117 + {
1.1118 + TheTest.Printf(_L("%d "), fsError);
1.1119 + __UHEAP_MARK;
1.1120 + (void)TheFs.SetErrorCondition(fsError, cnt);
1.1121 + RFileBuf64 fbuf(1024);//buffer capacity = 1024 bytes
1.1122 + TFileName tmpFileName;
1.1123 + err = fbuf.Temp(TheFs, KTestDir, tmpFileName, EFileWrite | EFileRead);
1.1124 + (void)TheFs.SetErrorCondition(KErrNone);
1.1125 + fbuf.Close();
1.1126 + __UHEAP_MARKEND;
1.1127 + TInt err2 = TheFs.Delete(tmpFileName);
1.1128 + TInt expectedErr = err == KErrNone ? KErrNone : KErrNotFound;
1.1129 + TEST2(err2, expectedErr);
1.1130 + }
1.1131 + TheTest.Printf(_L("\r\n"));
1.1132 + }
1.1133 + TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\n"), cnt);
1.1134 + }
1.1135 +
1.1136 +/**
1.1137 +@SYMTestCaseID PDS-SQL-UT-4207
1.1138 +@SYMTestCaseDesc RFileBuf64::Write() OOM test.
1.1139 + The test calls RFileBuf64:Write() in an OOM
1.1140 + simulation loop and verifies that no memory is leaked.
1.1141 + The test also check that RFileBuf::DoSetCapacity() correctly operates in
1.1142 + "out of memory" situation.
1.1143 +@SYMTestActions RFileBuf64::Write() OOM test.
1.1144 +@SYMTestExpectedResults Test must not fail
1.1145 +@SYMTestPriority High
1.1146 +@SYMDEF 380056
1.1147 +*/
1.1148 +void WriteOomTest()
1.1149 + {
1.1150 + HBufC8* databuf = HBufC8::New(KPageSize);
1.1151 + TEST(databuf != NULL);
1.1152 + TPtr8 dataptr = databuf->Des();
1.1153 + dataptr.SetLength(KPageSize);
1.1154 + dataptr.Fill(TChar(KChar));
1.1155 +
1.1156 + TInt err = KErrNoMemory;
1.1157 + TInt failingAllocationNo = 0;
1.1158 + TheTest.Printf(_L("Iteration:\r\n"));
1.1159 + while(err == KErrNoMemory)
1.1160 + {
1.1161 + TheTest.Printf(_L(" %d"), ++failingAllocationNo);
1.1162 +
1.1163 + (void)TheFs.Delete(KTestFile);
1.1164 +
1.1165 + MarkHandles();
1.1166 + MarkAllocatedCells();
1.1167 +
1.1168 + __UHEAP_MARK;
1.1169 + __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
1.1170 +
1.1171 + const TInt KDefaultBufCapacity = 1024;
1.1172 + RFileBuf64 fbuf(KDefaultBufCapacity);
1.1173 + err = fbuf.Create(TheFs, KTestFile, EFileWrite | EFileRead);
1.1174 + if(err == KErrNone)
1.1175 + {
1.1176 + err = fbuf.Write(0LL, dataptr);
1.1177 + }
1.1178 + fbuf.Close();
1.1179 +
1.1180 + __UHEAP_RESET;
1.1181 + __UHEAP_MARKEND;
1.1182 +
1.1183 + CheckAllocatedCells();
1.1184 + CheckHandles();
1.1185 + }
1.1186 + TEST2(err, KErrNone);
1.1187 + RFile64 file;
1.1188 + err = file.Open(TheFs, KTestFile, EFileRead);
1.1189 + TEST2(err, KErrNone);
1.1190 + dataptr.Zero();
1.1191 + err = file.Read(dataptr);
1.1192 + TEST2(err, KErrNone);
1.1193 + file.Close();
1.1194 + TEST2(dataptr.Length(), KPageSize);
1.1195 + for(TInt i=0;i<KPageSize;++i)
1.1196 + {
1.1197 + TEST(dataptr[i] == KChar);
1.1198 + }
1.1199 + TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
1.1200 +
1.1201 + //The file is left undeleted - to be used in ReadOomTest().
1.1202 + delete databuf;
1.1203 + }
1.1204 +
1.1205 +/**
1.1206 +@SYMTestCaseID PDS-SQL-UT-4208
1.1207 +@SYMTestCaseDesc RFileBuf64::Read() OOM test.
1.1208 + The test calls RFileBuf64:Read() in an OOM
1.1209 + simulation loop and verifies that no memory is leaked.
1.1210 + The test also check that RFileBuf::DoSetCapacity() correctly operates in
1.1211 + "out of memory" situation.
1.1212 +@SYMTestActions RFileBuf64::Read() OOM test.
1.1213 +@SYMTestExpectedResults Test must not fail
1.1214 +@SYMTestPriority High
1.1215 +@SYMDEF 380056
1.1216 +*/
1.1217 +void ReadOomTest()
1.1218 + {
1.1219 + HBufC8* databuf = HBufC8::New(KPageSize);
1.1220 + TEST(databuf != NULL);
1.1221 + TPtr8 dataptr = databuf->Des();
1.1222 +
1.1223 + TInt err = KErrNoMemory;
1.1224 + TInt failingAllocationNo = 0;
1.1225 + TheTest.Printf(_L("Iteration:\r\n"));
1.1226 + while(err == KErrNoMemory)
1.1227 + {
1.1228 + TheTest.Printf(_L(" %d"), ++failingAllocationNo);
1.1229 +
1.1230 + MarkHandles();
1.1231 + MarkAllocatedCells();
1.1232 +
1.1233 + __UHEAP_MARK;
1.1234 + __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, failingAllocationNo, KBurstRate);
1.1235 +
1.1236 + const TInt KDefaultBufCapacity = 1024;
1.1237 + RFileBuf64 fbuf(KDefaultBufCapacity);
1.1238 + err = fbuf.Open(TheFs, KTestFile, EFileRead);
1.1239 + if(err == KErrNone)
1.1240 + {
1.1241 + err = fbuf.Read(0LL, dataptr);
1.1242 + }
1.1243 + fbuf.Close();
1.1244 +
1.1245 + __UHEAP_RESET;
1.1246 + __UHEAP_MARKEND;
1.1247 +
1.1248 + CheckAllocatedCells();
1.1249 + CheckHandles();
1.1250 + }
1.1251 + TEST2(err, KErrNone);
1.1252 + RFile64 file;
1.1253 + err = file.Open(TheFs, KTestFile, EFileRead);
1.1254 + TEST2(err, KErrNone);
1.1255 + dataptr.Zero();
1.1256 + err = file.Read(dataptr);
1.1257 + TEST2(err, KErrNone);
1.1258 + file.Close();
1.1259 + TEST2(dataptr.Length(), KPageSize);
1.1260 + for(TInt i=0;i<KPageSize;++i)
1.1261 + {
1.1262 + TEST(dataptr[i] == KChar);
1.1263 + }
1.1264 + TheTest.Printf(_L("\r\n=== OOM Test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);
1.1265 +
1.1266 + (void)TheFs.Delete(KTestFile);
1.1267 + delete databuf;
1.1268 + }
1.1269 +
1.1270 +/**
1.1271 +@SYMTestCaseID PDS-SQL-CT-4212
1.1272 +@SYMTestCaseDesc RFileBuf64::Write() test.
1.1273 + The test performs file write operations using RFileBuf64 class.
1.1274 + Teh test sumilates the write operation at the conditions:
1.1275 +
1.1276 + 1. There are 8 pages to be writted to the file.
1.1277 + 2. Each page is 16 bytes
1.1278 + 3. The size of RFileBuf64 is 4 pages, i.e. 64 bytes.
1.1279 + 4. The order of write is not sequential.
1.1280 +
1.1281 +@SYMTestActions Write database pages.
1.1282 +@SYMTestExpectedResults Test must not fail
1.1283 +@SYMTestPriority High
1.1284 +*/
1.1285 +void TestSetSizeCounter()
1.1286 + {
1.1287 + const TInt KPageSize = 16;
1.1288 + const TInt KBufSize = 4 * KPageSize;
1.1289 + RFileBuf64 fbuf(KBufSize);
1.1290 + (void)TheFs.Delete(KTestFile);
1.1291 + TInt err = fbuf.Create(TheFs, KTestFile, EFileRead | EFileWrite);
1.1292 + TEST2(err, KErrNone);
1.1293 + const TInt KMaxPage = 8;
1.1294 + TUint8 fileData[KMaxPage][KPageSize];
1.1295 + TPtrC8 pageData[KMaxPage];
1.1296 + for(TInt i = 0;i <KMaxPage;++i)
1.1297 + {
1.1298 + Mem::Fill(fileData[i], KPageSize, TChar('a' + i));
1.1299 + const TUint8* p = fileData[i];
1.1300 + pageData[i].Set(p, KPageSize);
1.1301 + }
1.1302 + //
1.1303 + fbuf.ProfilerReset();
1.1304 + //Write the first 4 pages
1.1305 + for (TInt ii = 0; ii < 4; ii++)
1.1306 + {
1.1307 + err = fbuf.Write(ii * KPageSize, pageData[ii]);
1.1308 + TEST2(err, KErrNone);
1.1309 + }
1.1310 + //Write page #2
1.1311 + err = fbuf.Write(2 * KPageSize, pageData[2]);
1.1312 + TEST2(err, KErrNone);
1.1313 + //
1.1314 + TEST2(fbuf.iFileWriteCount, 0);
1.1315 + TEST2(fbuf.iFileSetSizeCount, 0);
1.1316 + //Write pages 5, 4, 6, 7
1.1317 + err = fbuf.Write(5 * KPageSize, pageData[5]);
1.1318 + TEST2(err, KErrNone);
1.1319 + //
1.1320 + TEST2(fbuf.iFileWriteCount, 1);
1.1321 + TEST2(fbuf.iFileSetSizeCount, 0);
1.1322 + //
1.1323 + err = fbuf.Write(4 * KPageSize, pageData[4]);
1.1324 + TEST2(err, KErrNone);
1.1325 + err = fbuf.Write(6 * KPageSize, pageData[6]);
1.1326 + TEST2(err, KErrNone);
1.1327 + err = fbuf.Write(7 * KPageSize, pageData[7]);
1.1328 + TEST2(err, KErrNone);
1.1329 + //
1.1330 + TEST2(fbuf.iFileWriteCount, 1);
1.1331 + TEST2(fbuf.iFileSetSizeCount, 0);
1.1332 + //
1.1333 + err = fbuf.Flush();
1.1334 + TEST2(err, KErrNone);
1.1335 + //
1.1336 + TEST2(fbuf.iFileWriteCount, 2);
1.1337 + TEST2(fbuf.iFileSetSizeCount, 0);
1.1338 + //
1.1339 + fbuf.Close();
1.1340 + (void)TheFs.Delete(KTestFile);
1.1341 + }
1.1342 +
1.1343 +///////////////////////////////////////////////////////////////////////////////////////
1.1344 +
1.1345 +#ifdef _DEBUG
1.1346 +
1.1347 +//Panic thread function.
1.1348 +//It will cast aData parameter to a TFunctor pointer and call it.
1.1349 +//The expectation is that the called function will panic and kill the panic thread.
1.1350 +TInt ThreadFunc(void* aData)
1.1351 + {
1.1352 + CTrapCleanup* tc = CTrapCleanup::New();
1.1353 + TEST(tc != NULL);
1.1354 +
1.1355 + User::SetJustInTime(EFalse); // disable debugger panic handling
1.1356 +
1.1357 + TFunctor* obj = reinterpret_cast<TFunctor*> (aData);
1.1358 + TEST(obj != NULL);
1.1359 + (*obj)();//call the panic function
1.1360 +
1.1361 + delete tc;
1.1362 +
1.1363 + return KErrNone;
1.1364 + }
1.1365 +
1.1366 +//Panic test.
1.1367 +//PanicTest function will create a new thread - panic thread, giving it a pointer to the function which has to
1.1368 +//be executed and the expectation is that the function will panic and kill the panic thread.
1.1369 +//PanicTest function will check the panic thread exit code, exit category and the panic code.
1.1370 +void PanicTest(TFunctor& aFunctor, TExitType aExpectedExitType, const TDesC& aExpectedCategory, TInt aExpectedPanicCode)
1.1371 + {
1.1372 + RThread thread;
1.1373 + _LIT(KThreadName,"SqlFileBufPanicThread");
1.1374 + TEST2(thread.Create(KThreadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&aFunctor, EOwnerThread), KErrNone);
1.1375 +
1.1376 + TRequestStatus status;
1.1377 + thread.Logon(status);
1.1378 + TEST2(status.Int(), KRequestPending);
1.1379 + thread.Resume();
1.1380 + User::WaitForRequest(status);
1.1381 + User::SetJustInTime(ETrue); // enable debugger panic handling
1.1382 +
1.1383 + TEST2(thread.ExitType(), aExpectedExitType);
1.1384 + TEST(thread.ExitCategory() == aExpectedCategory);
1.1385 + TEST2(thread.ExitReason(), aExpectedPanicCode);
1.1386 +
1.1387 + CLOSE_AND_WAIT(thread);
1.1388 + }
1.1389 +
1.1390 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1391 +////////////////////////////// Panic test functions /////////////////////////////////////////////////
1.1392 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.1393 +
1.1394 +//Panic when calling RFileBuf64::RFileBuf64() with an invalid buffer capacity value.
1.1395 +class TSqlFileBuf_InvalidCapacity : public TFunctor
1.1396 + {
1.1397 +private:
1.1398 + virtual void operator()()
1.1399 + {
1.1400 + RFileBuf64 fbuf(-8192);//panic here - "-8192" - negative buffer capacity
1.1401 + }
1.1402 + };
1.1403 +static TSqlFileBuf_InvalidCapacity TheSqlFileBuf_InvalidCapacity;
1.1404 +
1.1405 +//Panic when calling RFileBuf64::Create() with an invalid file handle.
1.1406 +class TSqlFileBuf_InvalidFileHandle1 : public TFunctor
1.1407 + {
1.1408 +private:
1.1409 + virtual void operator()()
1.1410 + {
1.1411 + RFileBuf64 fbuf(8192);
1.1412 + RFs fs;
1.1413 + fbuf.Create(fs, _L("aaa.db"), EFileRead);//panic here - invalid file handle
1.1414 + }
1.1415 + };
1.1416 +static TSqlFileBuf_InvalidFileHandle1 TheSqlFileBuf_InvalidFileHandle1;
1.1417 +
1.1418 +//Panic when calling RFileBuf64::Create() with an invalid file name.
1.1419 +class TSqlFileBuf_InvalidFileName1 : public TFunctor
1.1420 + {
1.1421 +private:
1.1422 + virtual void operator()()
1.1423 + {
1.1424 + RFileBuf64 fbuf(8192);
1.1425 + RFs fs;
1.1426 + TInt err = fs.Connect();
1.1427 + TEST2(err, KErrNone);
1.1428 + fbuf.Create(fs, KNullDesC, EFileRead);//panic here - invalid file name
1.1429 + fs.Close();
1.1430 + }
1.1431 + };
1.1432 +static TSqlFileBuf_InvalidFileName1 TheSqlFileBuf_InvalidFileName1;
1.1433 +
1.1434 +//Panic when calling RFileBuf64::Open() with an invalid file handle.
1.1435 +class TSqlFileBuf_InvalidFileHandle2 : public TFunctor
1.1436 + {
1.1437 +private:
1.1438 + virtual void operator()()
1.1439 + {
1.1440 + RFileBuf64 fbuf(8192);
1.1441 + RFs fs;
1.1442 + fbuf.Open(fs, _L("aaa.db"), EFileRead);//panic here - invalid file handle
1.1443 + }
1.1444 + };
1.1445 +static TSqlFileBuf_InvalidFileHandle2 TheSqlFileBuf_InvalidFileHandle2;
1.1446 +
1.1447 +//Panic when calling RFileBuf64::Open() with an invalid file name.
1.1448 +class TSqlFileBuf_InvalidFileName2 : public TFunctor
1.1449 + {
1.1450 +private:
1.1451 + virtual void operator()()
1.1452 + {
1.1453 + RFileBuf64 fbuf(8192);
1.1454 + RFs fs;
1.1455 + TInt err = fs.Connect();
1.1456 + TEST2(err, KErrNone);
1.1457 + fbuf.Open(fs, KNullDesC, EFileRead);//panic here - invalid file name
1.1458 + fs.Close();
1.1459 + }
1.1460 + };
1.1461 +static TSqlFileBuf_InvalidFileName2 TheSqlFileBuf_InvalidFileName2;
1.1462 +
1.1463 +//Panic when calling RFileBuf64::Temp() with an invalid file handle.
1.1464 +class TSqlFileBuf_InvalidFileHandle3 : public TFunctor
1.1465 + {
1.1466 +private:
1.1467 + virtual void operator()()
1.1468 + {
1.1469 + RFileBuf64 fbuf(8192);
1.1470 + RFs fs;
1.1471 + TFileName fname;
1.1472 + fbuf.Temp(fs, _L("c:\\test"), fname, EFileRead);//panic here - invalid file handle
1.1473 + }
1.1474 + };
1.1475 +static TSqlFileBuf_InvalidFileHandle3 TheSqlFileBuf_InvalidFileHandle3;
1.1476 +
1.1477 +//Panic when calling RFileBuf64::AdoptFromClient() with an invalid message handle.
1.1478 +class TSqlFileBuf_InvalidMessageHandle : public TFunctor
1.1479 + {
1.1480 +private:
1.1481 + virtual void operator()()
1.1482 + {
1.1483 + RFileBuf64 fbuf(8192);
1.1484 + RMessage2 msg;
1.1485 + fbuf.AdoptFromClient(msg, 0, 1);//panic here - invalid message handle
1.1486 + }
1.1487 + };
1.1488 +static TSqlFileBuf_InvalidMessageHandle TheSqlFileBuf_InvalidMessageHandle;
1.1489 +
1.1490 +//Panic when calling RFileBuf64::Read() with an invalid file position.
1.1491 +class TSqlFileBuf_InvalidReadPos : public TFunctor
1.1492 + {
1.1493 +private:
1.1494 + virtual void operator()()
1.1495 + {
1.1496 + RFileBuf64 fbuf(8192);
1.1497 + TBuf8<50> buf;
1.1498 + fbuf.Read(-1024, buf);//panic here - invalid file position
1.1499 + }
1.1500 + };
1.1501 +static TSqlFileBuf_InvalidReadPos TheSqlFileBuf_InvalidReadPos;
1.1502 +
1.1503 +//Panic when calling RFileBuf64::Write() with an invalid file position.
1.1504 +class TSqlFileBuf_InvalidWritePos : public TFunctor
1.1505 + {
1.1506 +private:
1.1507 + virtual void operator()()
1.1508 + {
1.1509 + RFileBuf64 fbuf(8192);
1.1510 + TBuf8<50> buf;
1.1511 + fbuf.Write(-1024, buf);//panic here - invalid file position
1.1512 + }
1.1513 + };
1.1514 +static TSqlFileBuf_InvalidWritePos TheSqlFileBuf_InvalidWritePos;
1.1515 +
1.1516 +//Panic when calling RFileBuf64::SetSize() with an invalid file size.
1.1517 +class TSqlFileBuf_InvalidSize : public TFunctor
1.1518 + {
1.1519 +private:
1.1520 + virtual void operator()()
1.1521 + {
1.1522 + RFileBuf64 fbuf(8192);
1.1523 + TBuf8<50> buf;
1.1524 + fbuf.SetSize(-1024);//panic here - invalid file size
1.1525 + }
1.1526 + };
1.1527 +static TSqlFileBuf_InvalidSize TheSqlFileBuf_InvalidSize;
1.1528 +
1.1529 +#endif //_DEBUG
1.1530 +
1.1531 +/**
1.1532 +@SYMTestCaseID PDS-SQL-UT-4236
1.1533 +@SYMTestCaseDesc RFileBuf64 panic test.
1.1534 + The test runs a thread. The thread will create a RFileBuf64 object
1.1535 + and put the object in a situation where the file buffer cannot perform
1.1536 + its duties anymore and will raise a panic. The test verifies that the file
1.1537 + buffer implementation properly detects anomalities such as bad parameters,
1.1538 + null handles, etc...
1.1539 +@SYMTestActions RFileBuf64 panic test.
1.1540 +@SYMTestExpectedResults Test must not fail
1.1541 +@SYMTestPriority High
1.1542 +*/
1.1543 +void FileBufPanicTest()
1.1544 + {
1.1545 +#ifdef _DEBUG
1.1546 + _LIT(KPanicCategory, "FBuf64");
1.1547 + PanicTest(TheSqlFileBuf_InvalidCapacity, EExitPanic, KPanicCategory, 1);
1.1548 + PanicTest(TheSqlFileBuf_InvalidFileHandle1, EExitPanic, KPanicCategory, 7);
1.1549 + PanicTest(TheSqlFileBuf_InvalidFileName1, EExitPanic, KPanicCategory, 10);
1.1550 + PanicTest(TheSqlFileBuf_InvalidFileHandle2, EExitPanic, KPanicCategory, 7);
1.1551 + PanicTest(TheSqlFileBuf_InvalidFileName2, EExitPanic, KPanicCategory, 10);
1.1552 + PanicTest(TheSqlFileBuf_InvalidFileHandle3, EExitPanic, KPanicCategory, 7);
1.1553 + PanicTest(TheSqlFileBuf_InvalidMessageHandle, EExitPanic, KPanicCategory, 8);
1.1554 + PanicTest(TheSqlFileBuf_InvalidReadPos, EExitPanic, KPanicCategory, 4);
1.1555 + PanicTest(TheSqlFileBuf_InvalidWritePos, EExitPanic, KPanicCategory, 4);
1.1556 + PanicTest(TheSqlFileBuf_InvalidSize, EExitPanic, KPanicCategory, 5);
1.1557 +#else //_DEBUG
1.1558 + TheTest.Printf(_L("This test can be run in _DEBUG mode only!"));
1.1559 +#endif//_DEBUG
1.1560 + }
1.1561 +
1.1562 +void DoTests()
1.1563 + {
1.1564 + TheTest.Start(_L(" @SYMTestCaseID:PDS-SQL-UT-4132 RFileBuf64 write test 1"));
1.1565 + WriteTest1();
1.1566 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4133 RFileBuf64 write test 2"));
1.1567 + WriteTest2();
1.1568 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4134 RFileBuf64 write test 3"));
1.1569 + WriteTest3();
1.1570 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4135 RFileBuf64 write test 4"));
1.1571 + WriteTest4();
1.1572 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4136 RFileBuf64 write test 5"));
1.1573 + WriteTest5();
1.1574 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4137 RFileBuf64 write test 6"));
1.1575 + WriteTest6();
1.1576 + TheTest.Next( _L("RFileBuf64 read test - preparation"));
1.1577 + PrepareReadTest();
1.1578 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4138 RFileBuf64 read test 1"));
1.1579 + ReadTest1();
1.1580 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4139 RFileBuf64 read test 2"));
1.1581 + ReadTest2();
1.1582 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4140 RFileBuf64 read test 3"));
1.1583 + ReadTest3();
1.1584 +
1.1585 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4141 RFileBuf64::SetReadAheadSize() test"));
1.1586 + SetReadAheadSizeTest();
1.1587 +
1.1588 + (void)TheFs.Delete(KTestFile);
1.1589 +
1.1590 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4142 RFileBuf64::Create() OOM test"));
1.1591 + OomTest(EOomCreateTest);
1.1592 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4142 RFileBuf64::Open() OOM test"));
1.1593 + OomTest(EOomOpenTest);
1.1594 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4142 RFileBuf64::Temp() OOM test"));
1.1595 + OomTest(EOomTempTest);
1.1596 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4207 RFileBuf64::Write() OOM test"));
1.1597 + WriteOomTest();
1.1598 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4208 RFileBuf64::Read() OOM test"));
1.1599 + ReadOomTest();
1.1600 +
1.1601 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4195 RFileBuf64::Create() file I/O error simulation test"));
1.1602 + CreateFileIoErrTest();
1.1603 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4196 RFileBuf64::Open() file I/O error simulation test"));
1.1604 + OpenFileIoErrTest();
1.1605 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4197 RFileBuf64::Temp() file I/O error simulation test"));
1.1606 + OpenFileIoErrTest();
1.1607 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-CT-4212 RFileBuf64::Write() test"));
1.1608 + TestSetSizeCounter();
1.1609 +
1.1610 + TheTest.Next( _L(" @SYMTestCaseID:PDS-SQL-UT-4236 RFileBuf64 panic test"));
1.1611 + FileBufPanicTest();
1.1612 + }
1.1613 +
1.1614 +TInt E32Main()
1.1615 + {
1.1616 + TheTest.Title();
1.1617 +
1.1618 + CTrapCleanup* tc = CTrapCleanup::New();
1.1619 + TheTest(tc != NULL);
1.1620 +
1.1621 + __UHEAP_MARK;
1.1622 +
1.1623 + TestEnvInit();
1.1624 + DeleteTestFiles();
1.1625 + DoTests();
1.1626 + TestEnvDestroy();
1.1627 +
1.1628 + __UHEAP_MARKEND;
1.1629 +
1.1630 + TheTest.End();
1.1631 + TheTest.Close();
1.1632 +
1.1633 + delete tc;
1.1634 +
1.1635 + User::Heap().Check();
1.1636 + return KErrNone;
1.1637 + }
1.1638 +
1.1639 +#else//_SQLPROFILER
1.1640 +
1.1641 +TInt E32Main()
1.1642 + {
1.1643 + TheTest.Title();
1.1644 +
1.1645 + TheTest.Start(_L("This test works only if the test is built with _SQLPROFILER macro defined!"));
1.1646 + TheTest.End();
1.1647 + TheTest.Close();
1.1648 +
1.1649 + return KErrNone;
1.1650 + }
1.1651 +
1.1652 +#endif//_SQLPROFILER