1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/TEST/t_sqloslayer.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,910 @@
1.4 +// Copyright (c) 2006-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 +
1.19 +#include <e32test.h>
1.20 +#include <bautils.h>
1.21 +#include <stdlib.h>
1.22 +#include <string.h>
1.23 +#include <hal.h>
1.24 +#include "SqliteSymbian.h"
1.25 +#ifdef __cplusplus
1.26 +extern "C" {
1.27 +#endif
1.28 + #include "sqliteInt.h"
1.29 + #include "os.h"
1.30 +#ifdef __cplusplus
1.31 +} /* End of the 'extern "C"' block */
1.32 +#endif
1.33 +#include "SqliteUtil.h"
1.34 +
1.35 +///////////////////////////////////////////////////////////////////////////////////////
1.36 +
1.37 +const char* KSymbianVfsNameZ = "SymbianSql";
1.38 +
1.39 +RTest TheTest(_L("t_sqloslayer test"));
1.40 +RFs TheFs;
1.41 +
1.42 +_LIT(KTestDir, "c:\\test\\");
1.43 +_LIT(KTestFile1, "c:\\test\\t_sqloslayer.bin");
1.44 +_LIT(KTestFile3, "c:\\test\\t_sqloslayer.db");
1.45 +const char* KTestFile1Z = "c:\\test\\t_sqloslayer.bin";
1.46 +const char* KTestFile2Z = "z:\\test\\TestDb1.db";
1.47 +const char* KTestFile3Z = "c:\\test\\t_sqloslayer.db";
1.48 +_LIT(KPrivateDir, "c:\\private\\21F12127\\");
1.49 +const char* KTestFile4Z = "c:\\test\\t_sqloslayer2.db";
1.50 +
1.51 +//In order to be able to compile the test, the following variables are defined (used inside the OS porting layer, when _SQLPROFILER macro is defined)
1.52 +#ifdef _SQLPROFILER
1.53 +TInt TheSqlSrvProfilerFileRead = 0;
1.54 +TInt TheSqlSrvProfilerFileWrite = 0;
1.55 +TInt TheSqlSrvProfilerFileSync = 0;
1.56 +TInt TheSqlSrvProfilerFileSetSize = 0;
1.57 +#endif
1.58 +
1.59 +#ifdef _DEBUG
1.60 +//SQLite panic category.
1.61 +_LIT(KSqlitePanicCategory, "Sqlite");
1.62 +#endif
1.63 +
1.64 +///////////////////////////////////////////////////////////////////////////////////////
1.65 +
1.66 +void DeleteTestFiles()
1.67 + {
1.68 + (void)TheFs.Delete(KTestFile3);
1.69 + (void)TheFs.Delete(KTestFile1);
1.70 + }
1.71 +
1.72 +void TestEnvDestroy()
1.73 + {
1.74 + sqlite3SymbianLibFinalize();
1.75 + DeleteTestFiles();
1.76 + TheFs.Close();
1.77 + }
1.78 +
1.79 +///////////////////////////////////////////////////////////////////////////////////////
1.80 +///////////////////////////////////////////////////////////////////////////////////////
1.81 +//Test macros and functions
1.82 +void Check1(TInt aValue, TInt aLine)
1.83 + {
1.84 + if(!aValue)
1.85 + {
1.86 + TestEnvDestroy();
1.87 + RDebug::Print(_L("*** Line %d\r\n"), aLine);
1.88 + TheTest(EFalse, aLine);
1.89 + }
1.90 + }
1.91 +void Check2(TInt aValue, TInt aExpected, TInt aLine)
1.92 + {
1.93 + if(aValue != aExpected)
1.94 + {
1.95 + TestEnvDestroy();
1.96 + RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
1.97 + TheTest(EFalse, aLine);
1.98 + }
1.99 + }
1.100 +#define TEST(arg) ::Check1((arg), __LINE__)
1.101 +#define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
1.102 +
1.103 +///////////////////////////////////////////////////////////////////////////////////////
1.104 +
1.105 +static TInt TheProcessHandleCount = 0;
1.106 +static TInt TheThreadHandleCount = 0;
1.107 +static TInt TheAllocatedCellsCount = 0;
1.108 +
1.109 +#ifdef _DEBUG
1.110 +static const TInt KBurstRate = 20;
1.111 +#endif
1.112 +
1.113 +static void MarkHandles()
1.114 + {
1.115 + RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);
1.116 + }
1.117 +
1.118 +static void MarkAllocatedCells()
1.119 + {
1.120 + TheAllocatedCellsCount = User::CountAllocCells();
1.121 + }
1.122 +
1.123 +static void CheckAllocatedCells()
1.124 + {
1.125 + TInt allocatedCellsCount = User::CountAllocCells();
1.126 + TEST2(allocatedCellsCount, TheAllocatedCellsCount);
1.127 + }
1.128 +
1.129 +static void CheckHandles()
1.130 + {
1.131 + TInt endProcessHandleCount;
1.132 + TInt endThreadHandleCount;
1.133 +
1.134 + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);
1.135 +
1.136 + TEST2(TheProcessHandleCount, endProcessHandleCount);
1.137 + TEST2(TheThreadHandleCount, endThreadHandleCount);
1.138 + }
1.139 +
1.140 +static void OomPreStep(TInt
1.141 +#ifdef _DEBUG
1.142 + aFailingAllocationNo
1.143 +#endif
1.144 + )
1.145 + {
1.146 + MarkHandles();
1.147 + MarkAllocatedCells();
1.148 + __UHEAP_MARK;
1.149 + __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, aFailingAllocationNo, KBurstRate);
1.150 + }
1.151 +
1.152 +static void OomPostStep()
1.153 + {
1.154 + __UHEAP_RESET;
1.155 + __UHEAP_MARKEND;
1.156 + CheckAllocatedCells();
1.157 + CheckHandles();
1.158 + }
1.159 +
1.160 +///////////////////////////////////////////////////////////////////////////////////////
1.161 +
1.162 +void TestEnvInit()
1.163 + {
1.164 + TInt err = TheFs.Connect();
1.165 + TEST2(err, KErrNone);
1.166 +
1.167 + err = TheFs.MkDir(KTestDir);
1.168 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.169 +
1.170 + err = sqlite3SymbianLibInit();
1.171 + TEST2(err, KErrNone);
1.172 + }
1.173 +
1.174 +TInt CalcMs(TUint32 aStartTicks, TUint32 aEndTicks)
1.175 + {
1.176 + static TInt freq = 0;
1.177 + if(freq == 0)
1.178 + {
1.179 + TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);
1.180 + }
1.181 + TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;
1.182 + if(diffTicks < 0)
1.183 + {
1.184 + diffTicks = KMaxTUint32 + diffTicks + 1;
1.185 + }
1.186 + const TInt KMicroSecIn1Sec = 1000000;
1.187 + TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;
1.188 + return us / 1000;
1.189 + }
1.190 +
1.191 +///////////////////////////////////////////////////////////////////////////////////////
1.192 +
1.193 +//Create/open/close/delete a file
1.194 +void Test1()
1.195 + {
1.196 + sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);
1.197 + TEST(vfs != NULL);
1.198 +
1.199 + sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);
1.200 + TEST(osFile != NULL);
1.201 +
1.202 + //Creating a new file
1.203 + int outFlags = 0;
1.204 + int err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, &outFlags);
1.205 + TEST2(err, SQLITE_OK);
1.206 + TEST(outFlags & SQLITE_OPEN_READWRITE);
1.207 + err = sqlite3OsClose(osFile);
1.208 + TEST2(err, SQLITE_OK);
1.209 + //Opening an existing file for R/W
1.210 + err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READWRITE, &outFlags);
1.211 + TEST2(err, SQLITE_OK);
1.212 + TEST(outFlags & SQLITE_OPEN_READWRITE);
1.213 + err = sqlite3OsClose(osFile);
1.214 + TEST2(err, SQLITE_OK);
1.215 + //Opening a read-only file
1.216 + err = sqlite3OsOpen(vfs, KTestFile2Z, osFile, SQLITE_OPEN_READWRITE, &outFlags);
1.217 + TEST2(err, SQLITE_OK);
1.218 + TEST(outFlags & SQLITE_OPEN_READONLY);
1.219 + //Truncate a read-only file
1.220 + err = osFile->pMethods->xTruncate(osFile, 0);
1.221 + TEST2(err, SQLITE_IOERR);
1.222 + //xAccess - read-only file
1.223 + int res = 0;
1.224 + err = vfs->xAccess(vfs, KTestFile2Z, SQLITE_ACCESS_READ, &res);
1.225 + TEST2(err, SQLITE_OK);
1.226 + TEST(res != 0);
1.227 + //xAccess - invalid request
1.228 + res = 0;
1.229 + err = vfs->xAccess(vfs, KTestFile2Z, 122, &res);
1.230 + TEST2(err, SQLITE_OK);
1.231 + TEST2(res, 0);
1.232 + //
1.233 + err = sqlite3OsClose(osFile);
1.234 + TEST2(err, SQLITE_OK);
1.235 + //Creating a new file
1.236 + err = sqlite3OsOpen(vfs, KTestFile3Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, &outFlags);
1.237 + TEST2(err, SQLITE_OK);
1.238 + TEST(outFlags & SQLITE_OPEN_READWRITE);
1.239 + err = sqlite3OsClose(osFile);
1.240 + TEST2(err, SQLITE_OK);
1.241 + //Open a file for a read-only access
1.242 + err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READONLY, &outFlags);
1.243 + TEST2(err, SQLITE_OK);
1.244 + TEST(outFlags & SQLITE_OPEN_READONLY);
1.245 + err = sqlite3OsWrite(osFile, "1234", 4, 0);
1.246 + TEST(err != SQLITE_OK);
1.247 + err = sqlite3SymbianLastOsError();
1.248 + TEST2(err, KErrAccessDenied);
1.249 + err = vfs->xGetLastError(vfs, 0, 0);
1.250 + TEST2(err, 0);//Default implementation
1.251 + err = sqlite3OsClose(osFile);
1.252 + TEST2(err, SQLITE_OK);
1.253 + //Delete KTestFile3Z file
1.254 + err = sqlite3OsDelete(vfs, KTestFile3Z, 0);
1.255 + TEST2(err, SQLITE_OK);
1.256 + res = 0;
1.257 + err = sqlite3OsAccess(vfs, KTestFile3Z, SQLITE_ACCESS_EXISTS, &res);
1.258 + TEST2(err, SQLITE_OK);
1.259 + TEST2(res, 0);
1.260 + //Open a file for an exclusive access
1.261 + err = sqlite3OsOpen(vfs, KTestFile3Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_DELETEONCLOSE | SQLITE_OPEN_EXCLUSIVE, &outFlags);
1.262 + TEST2(err, SQLITE_OK);
1.263 + err = sqlite3OsClose(osFile);
1.264 + TEST2(err, SQLITE_OK);
1.265 + //The file should not exist now
1.266 + err = sqlite3OsAccess(vfs, KTestFile3Z, SQLITE_ACCESS_EXISTS, &res);
1.267 + TEST2(err, SQLITE_OK);
1.268 + TEST2(res, 0);
1.269 + //Open a file for an exclusive access without deleting it after
1.270 + err = sqlite3OsOpen(vfs, KTestFile3Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE, &outFlags);
1.271 + TEST2(err, SQLITE_OK);
1.272 + err = sqlite3OsClose(osFile);
1.273 + TEST2(err, SQLITE_OK);
1.274 + //The file should exist now
1.275 + err = sqlite3OsAccess(vfs, KTestFile3Z, SQLITE_ACCESS_EXISTS, &res);
1.276 + TEST2(err, SQLITE_OK);
1.277 + TEST2(res, 1);
1.278 + //Delete KTestFile3Z file
1.279 + err = sqlite3OsDelete(vfs, KTestFile3Z, 0);
1.280 + TEST2(err, SQLITE_OK);
1.281 + err = sqlite3OsAccess(vfs, KTestFile3Z, SQLITE_ACCESS_EXISTS, &res);
1.282 + TEST2(err, SQLITE_OK);
1.283 + TEST2(res, 0);
1.284 + //
1.285 + User::Free(osFile);
1.286 + }
1.287 +
1.288 +//Read/Write/Seek/Truncate test
1.289 +void Test2()
1.290 + {
1.291 + sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);
1.292 + TEST(vfs != NULL);
1.293 +
1.294 + sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);
1.295 + TEST(osFile != NULL);
1.296 +
1.297 + //Creating a new file
1.298 + int err = sqlite3OsDelete(vfs, KTestFile1Z, 0);
1.299 + TEST2(err, SQLITE_OK);
1.300 + int res = 0;
1.301 + err = sqlite3OsAccess(vfs, KTestFile1Z, SQLITE_ACCESS_EXISTS, &res);
1.302 + TEST2(err, SQLITE_OK);
1.303 + TEST2(res, 0);
1.304 + err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
1.305 + TEST2(err, SQLITE_OK);
1.306 + //Writing at the beginning of the file
1.307 + err = sqlite3OsWrite(osFile, "123456", 6, 0);
1.308 + TEST2(err, SQLITE_OK);
1.309 + //Verify the written data
1.310 + char data[20];
1.311 + err = sqlite3OsRead(osFile, data, 6, 0);
1.312 + TEST2(err, SQLITE_OK);
1.313 + err = memcmp(data, "123456", 6);
1.314 + TEST2(err, 0);
1.315 + //Writing at beyond the end of the file
1.316 + err = sqlite3OsWrite(osFile, "abcdefgh", 8, 100);
1.317 + TEST2(err, SQLITE_OK);
1.318 + //Verify the written data
1.319 + err = sqlite3OsRead(osFile, data, 8, 100);
1.320 + TEST2(err, SQLITE_OK);
1.321 + err = memcmp(data, "abcdefgh", 8);
1.322 + TEST2(err, 0);
1.323 + //Truncate the file
1.324 + err = sqlite3OsTruncate(osFile, 3);
1.325 + TEST2(err, SQLITE_OK);
1.326 + //Write more data
1.327 + err = sqlite3OsWrite(osFile, "xyz", 3, 3);
1.328 + TEST2(err, SQLITE_OK);
1.329 + //Verify the written data
1.330 + err = sqlite3OsRead(osFile, data, 6, 0);
1.331 + TEST2(err, SQLITE_OK);
1.332 + err = memcmp(data, "123xyz", 6);
1.333 + TEST2(err, 0);
1.334 + //Check the file size
1.335 + TInt64 fileSize = 0;
1.336 + err = sqlite3OsFileSize(osFile, &fileSize);
1.337 + TEST2(err, SQLITE_OK);
1.338 + TEST(fileSize == 6);
1.339 + //FileControl - lock type
1.340 + int lockType = -1;
1.341 + err = osFile->pMethods->xFileControl(osFile, SQLITE_FCNTL_LOCKSTATE, &lockType);
1.342 + TEST2(err, SQLITE_OK);
1.343 + TEST2(lockType, NO_LOCK);
1.344 + //FileControl - set callback - NULL callback
1.345 + err = osFile->pMethods->xFileControl(osFile, KSqlFcntlRegisterFreePageCallback, 0);
1.346 + TEST2(err, SQLITE_ERROR);
1.347 + //FileControl - set callback - invalid callback object
1.348 + TSqlFreePageCallback cbck;
1.349 + err = osFile->pMethods->xFileControl(osFile, KSqlFcntlRegisterFreePageCallback, &cbck);
1.350 + TEST2(err, SQLITE_ERROR);
1.351 + //FileControl - invalid op-code
1.352 + err = osFile->pMethods->xFileControl(osFile, 90234, 0);
1.353 + TEST2(err, SQLITE_ERROR);
1.354 + //Close the file
1.355 + err = sqlite3OsClose(osFile);
1.356 + TEST2(err, SQLITE_OK);
1.357 + //
1.358 + err = sqlite3OsDelete(vfs, KTestFile1Z, 0);
1.359 + TEST2(err, SQLITE_OK);
1.360 + User::Free(osFile);
1.361 + }
1.362 +
1.363 +//Miscellaneous tests
1.364 +void Test3()
1.365 + {
1.366 + sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);
1.367 + TEST(vfs != NULL);
1.368 + //Full path name - the full file name is specified
1.369 + char fname[KMaxFileName];
1.370 + const char* testFileName1 = "c:\\test\\abv.db";
1.371 + int err = sqlite3OsFullPathname(vfs, testFileName1, KMaxFileName, fname);
1.372 + TEST2(err, SQLITE_OK);
1.373 + err = strncasecmp(fname, testFileName1, strlen(testFileName1));
1.374 + TEST2(err, 0);
1.375 + //Full path name - no drive, the full file name is not specified
1.376 + const char* testFileName2 = "abv.db";
1.377 + const char* expectedFileName2 = "c:\\private\\21F12127\\abv.db";//"21F12127", the UID of the current test app
1.378 + err = sqlite3OsFullPathname(vfs, testFileName2, KMaxFileName, fname);
1.379 + TEST2(err, SQLITE_OK);
1.380 + err = strncasecmp(fname, expectedFileName2, strlen(expectedFileName2));
1.381 + TEST2(err, 0);
1.382 + //Full path name - drive present, the full file name is not specified
1.383 + const char* testFileName3 = "z:abv.db";
1.384 + const char* expectedFileName3 = "z:\\private\\21F12127\\abv.db";//"21F12127", the UID of the current test app
1.385 + err = sqlite3OsFullPathname(vfs, testFileName3, KMaxFileName, fname);
1.386 + TEST2(err, SQLITE_OK);
1.387 + err = strncasecmp(fname, expectedFileName3, strlen(expectedFileName3));
1.388 + TEST2(err, 0);
1.389 + //Is directory writable - test 1
1.390 + int res = 0;
1.391 + err = sqlite3OsAccess(vfs, "c:\\test", SQLITE_ACCESS_READWRITE, &res);
1.392 + TEST2(err, SQLITE_OK);
1.393 + TEST2(res, 1);
1.394 + //Is directory writable - test 2
1.395 + err = sqlite3OsAccess(vfs, "c:\\test\\", SQLITE_ACCESS_READWRITE, &res);
1.396 + TEST2(err, SQLITE_OK);
1.397 + TEST2(res, 1);
1.398 + //Is directory writable - test 3
1.399 + //Not a valid test. It is the media that's read only, not the directory.
1.400 + //err = sqlite3OsAccess(vfs, "z:\\test\\", SQLITE_ACCESS_READWRITE, &res);
1.401 + //TEST2(err, SQLITE_OK);
1.402 + //TEST2(res, 0);
1.403 + //Random seed
1.404 + const int KBufLen = 100;
1.405 + char buf[KBufLen];
1.406 + err = sqlite3OsRandomness(vfs, KBufLen, buf);
1.407 + TEST2(err, KBufLen);
1.408 + //Sleep
1.409 + TUint32 start = User::FastCounter();
1.410 + const TInt KSleepTime = 200000;//us
1.411 + (void)sqlite3OsSleep(vfs, KSleepTime);
1.412 + TUint32 end = User::FastCounter();
1.413 + TInt ms = CalcMs(start, end);
1.414 + TheTest.Printf(_L(" === sqlite3OsSleep() time=%d ms\r\n"), ms);
1.415 + //TEST(ms >= 80 && ms <= 320);// -60%..+60%
1.416 + }
1.417 +
1.418 +//Lock/unlock tests
1.419 +void Test5()
1.420 + {
1.421 + sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);
1.422 + TEST(vfs != NULL);
1.423 +
1.424 + sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);
1.425 + TEST(osFile != NULL);
1.426 +
1.427 + //Creating a new file
1.428 + int res = 0;
1.429 + int err = sqlite3OsAccess(vfs, KTestFile1Z, SQLITE_ACCESS_EXISTS, &res);
1.430 + TEST2(err, SQLITE_OK);
1.431 + TEST2(res, 0);
1.432 + err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
1.433 + TEST2(err, SQLITE_OK);
1.434 + //Lock/unlock
1.435 + //SHARED_LOCK
1.436 + err = sqlite3OsLock(osFile, SHARED_LOCK);
1.437 + TEST2(err, SQLITE_OK);
1.438 + err = sqlite3OsCheckReservedLock(osFile, &res);
1.439 + TEST2(err, SQLITE_OK);
1.440 + TEST2(res, 0);
1.441 + //RESERVED_LOCK
1.442 + err = sqlite3OsLock(osFile, RESERVED_LOCK);
1.443 + TEST2(err, SQLITE_OK);
1.444 + err = sqlite3OsCheckReservedLock(osFile, &res);
1.445 + TEST2(err, SQLITE_OK);
1.446 + TEST2(res, 1);
1.447 + //PENDING_LOCK
1.448 + err = sqlite3OsLock(osFile, PENDING_LOCK);
1.449 + TEST2(err, SQLITE_OK);
1.450 + //EXCLUSIVE_LOCK
1.451 + err = sqlite3OsLock(osFile, EXCLUSIVE_LOCK);
1.452 + TEST2(err, SQLITE_OK);
1.453 + //back to SHARED_LOCK
1.454 + err = sqlite3OsLock(osFile, SHARED_LOCK);
1.455 + TEST2(err, SQLITE_OK);
1.456 + //UNLOCK
1.457 + err = sqlite3OsUnlock(osFile, NO_LOCK);
1.458 + //Close the file
1.459 + err = sqlite3OsClose(osFile);
1.460 + TEST2(err, SQLITE_OK);
1.461 + //
1.462 + err = sqlite3OsDelete(vfs, KTestFile1Z, 0);
1.463 + TEST2(err, SQLITE_OK);
1.464 + User::Free(osFile);
1.465 + }
1.466 +
1.467 +//sqlite3SymbianLibInit() - OOM test
1.468 +void sqlite3SymbianLibInitOomTest()
1.469 + {
1.470 + sqlite3SymbianLibFinalize();
1.471 +
1.472 + TInt failingAllocNum = 0;
1.473 + TInt err = KErrNoMemory;
1.474 + while(err == KErrNoMemory)
1.475 + {
1.476 + OomPreStep(++failingAllocNum);
1.477 + err = sqlite3SymbianLibInit();
1.478 + sqlite3SymbianLibFinalize();
1.479 + OomPostStep();
1.480 + if(err != KErrNoMemory)
1.481 + {
1.482 + TEST2(err, KErrNone);
1.483 + }
1.484 + }
1.485 + TEST2(err, KErrNone);
1.486 + TheTest.Printf(_L("=== sqlite3SymbianLibInit() OOM test succeeded at allcoation %d\r\n"), failingAllocNum);
1.487 + }
1.488 +
1.489 +//sqlite3SymbianLibInit() - 'File I/O error simulation' test
1.490 +void sqlite3SymbianLibInitFsErrTest()
1.491 + {
1.492 + sqlite3SymbianLibFinalize();
1.493 +
1.494 + TInt sysDrive = static_cast<TInt>(RFs::GetSystemDrive());
1.495 + TDriveUnit drvUnit(sysDrive);
1.496 + TDriveName drvName = drvUnit.Name();
1.497 +
1.498 + TFileName path;
1.499 + TInt err = TheFs.PrivatePath(path);
1.500 + TEST2(err, KErrNone);
1.501 +
1.502 + TParse privDataCage;
1.503 + err = privDataCage.Set(drvName, &path, 0);
1.504 + TEST2(err, KErrNone);
1.505 +
1.506 + err = KErrNotFound;
1.507 + TInt cnt = 1;
1.508 + for(;err<KErrNone;++cnt)
1.509 + {
1.510 + for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
1.511 + {
1.512 + (void)TheFs.RmDir(privDataCage.FullName());
1.513 +
1.514 + TInt processHandleCnt = 0;
1.515 + TInt threadHandleCnt = 0;
1.516 + RThread().HandleCount(processHandleCnt, threadHandleCnt);
1.517 + TInt allocCellsCnt = User::CountAllocCells();
1.518 +
1.519 + (void)TheFs.SetErrorCondition(fsError, cnt);
1.520 + err = sqlite3SymbianLibInit();
1.521 + (void)TheFs.SetErrorCondition(KErrNone);
1.522 +
1.523 + if(err != KErrNone)
1.524 + {
1.525 + TInt processHandleCnt2 = 0;
1.526 + TInt threadHandleCnt2 = 0;
1.527 + RThread().HandleCount(processHandleCnt2, threadHandleCnt2);
1.528 + TEST2(processHandleCnt2, processHandleCnt);
1.529 + TEST2(threadHandleCnt2, threadHandleCnt);
1.530 + TInt allocCellsCnt2 = User::CountAllocCells();
1.531 + TEST2(allocCellsCnt2, allocCellsCnt);
1.532 + }
1.533 + else
1.534 + {
1.535 + sqlite3SymbianLibFinalize();
1.536 + }
1.537 + }
1.538 + }
1.539 + sqlite3SymbianLibFinalize();
1.540 + TheTest.Printf(_L("=== sqlite3SymbianLibInit() 'File I/O error simulation' test succeeded at iteration %d\r\n"), cnt);
1.541 + }
1.542 +
1.543 +//If _SQLPROFILER macro is not defined then all profiling PS porting layer functions should return KErrNotSupported.
1.544 +void ProfilerDisabledTest()
1.545 + {
1.546 +#ifndef _SQLPROFILER
1.547 + TInt err = sqlite3SymbianProfilerStart(0);
1.548 + TEST2(err, KErrNotSupported);
1.549 +
1.550 + err = sqlite3SymbianProfilerStop(0);
1.551 + TEST2(err, KErrNotSupported);
1.552 +
1.553 + err = sqlite3SymbianProfilerReset(0);
1.554 + TEST2(err, KErrNotSupported);
1.555 +
1.556 + TBuf8<1> res;
1.557 + err = sqlite3SymbianProfilerQuery(0, res);
1.558 + TEST2(err, KErrNotSupported);
1.559 + res = res;
1.560 +#else
1.561 + TheTest.Printf(_L(" The _SQLPROFILER macro is defined. The Profliling OS porting layer functions are tested in t_sqlapi2\r\n"));
1.562 +#endif
1.563 + }
1.564 +
1.565 +void NegativeTest()
1.566 + {
1.567 + TInt err = sqlite3SymbianLibInit();
1.568 + TEST2(err, KErrNone);
1.569 +
1.570 + sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);
1.571 + TEST(vfs != NULL);
1.572 +
1.573 + sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);
1.574 + TEST(osFile != NULL);
1.575 +
1.576 + //Creating a new file - the name is too long
1.577 + const char* KLongFileNameZ = "c:\\test\\0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789-0123456789.bin";
1.578 + int outFlags = 0;
1.579 + err = sqlite3OsOpen(vfs, KLongFileNameZ, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, &outFlags);
1.580 + TEST2(err, SQLITE_CANTOPEN);
1.581 +
1.582 + //Open a file - the name contains the '|', but not at position 0 (private database - bad name)
1.583 + const char* KBadFileNameZ = "c:\\test\\01|23456.bin";
1.584 + err = sqlite3OsOpen(vfs, KBadFileNameZ, osFile, SQLITE_OPEN_READWRITE, &outFlags);
1.585 + TEST2(err, SQLITE_CANTOPEN);
1.586 +
1.587 + //FullPathName() - the output buffer is too small
1.588 + const char* KFileNameZ = "c:\\test\\0123456.bin";
1.589 + char buf[5];
1.590 + err = vfs->xFullPathname(vfs, KFileNameZ, 5, buf);
1.591 + TEST2(err, SQLITE_ERROR);
1.592 +
1.593 + //FullPathName() - NULL output buffer
1.594 + err = vfs->xFullPathname(vfs, KFileNameZ, 5, NULL);
1.595 + TEST2(err, SQLITE_ERROR);
1.596 +
1.597 + //FullPathName() - NULL file name
1.598 + err = vfs->xFullPathname(vfs, NULL, 5, buf);
1.599 + TEST2(err, SQLITE_ERROR);
1.600 +
1.601 + //FullPathName() - the file name is too long
1.602 + err = vfs->xFullPathname(vfs, KLongFileNameZ, 5, buf);
1.603 + TEST2(err, SQLITE_ERROR);
1.604 +
1.605 + //FullPathName() - NULL file name
1.606 + err = vfs->xFullPathname(vfs, NULL, 5, buf);
1.607 + TEST2(err, SQLITE_ERROR);
1.608 +
1.609 + //Dellete file - NULL file name
1.610 + err = vfs->xDelete(vfs, 0, 0);
1.611 + TEST2(err, SQLITE_ERROR);
1.612 +
1.613 + //Delete file - the output buffer for the unicode file name is too small
1.614 + err = vfs->xDelete(vfs, KLongFileNameZ, 0);
1.615 + TEST2(err, SQLITE_ERROR);
1.616 +
1.617 + //Open file - NULL file name - this is a temp file name
1.618 + err = sqlite3OsOpen(vfs, NULL, osFile, SQLITE_OPEN_READWRITE, &outFlags);
1.619 + TEST2(err, SQLITE_OK);
1.620 + err = osFile->pMethods->xClose(osFile);
1.621 + TEST2(err, SQLITE_OK);
1.622 +
1.623 + //xAccess - too long file name
1.624 + int res = -1;
1.625 + err = vfs->xAccess(vfs, KLongFileNameZ, SQLITE_ACCESS_EXISTS, &res);
1.626 + TEST2(err, SQLITE_IOERR_ACCESS);
1.627 +
1.628 + //xAccess - NULL file name
1.629 + err = vfs->xAccess(vfs, 0, SQLITE_ACCESS_EXISTS, &res);
1.630 + TEST2(err, SQLITE_IOERR_ACCESS);
1.631 +
1.632 + User::Free(osFile);
1.633 + }
1.634 +
1.635 +TInt DoDeleteTempFiles()
1.636 + {
1.637 + CFileMan* fm = NULL;
1.638 + TRAPD(err, fm = CFileMan::NewL(TheFs));
1.639 + TEST2(err, KErrNone);
1.640 + TFileName path;
1.641 + path.Copy(KPrivateDir);
1.642 + path.Append(_L("temp\\"));
1.643 + path.Append(_L("*.$$$"));
1.644 + err = fm->Delete(path);
1.645 + delete fm;
1.646 + return err;
1.647 + }
1.648 +
1.649 +void VfsOpenTempFileOomTest()
1.650 + {
1.651 + //Delete all temp files in this test private data cage.
1.652 + TInt err = DoDeleteTempFiles();
1.653 + TEST(err == KErrNone || err == KErrNotFound);
1.654 +
1.655 + sqlite3_vfs* vfs = sqlite3_vfs_find(NULL);
1.656 + TEST(vfs != NULL);
1.657 +
1.658 + sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);
1.659 + TEST(osFile != NULL);
1.660 +
1.661 + TheTest.Printf(_L("Iteration: "));
1.662 + TInt failingAllocNum = 0;
1.663 + err = SQLITE_IOERR_NOMEM;
1.664 + while(err == SQLITE_IOERR_NOMEM)
1.665 + {
1.666 + ++failingAllocNum;
1.667 + TheTest.Printf(_L("%d "), failingAllocNum);
1.668 + OomPreStep(failingAllocNum);
1.669 + int outFlags = 0;
1.670 + err = sqlite3OsOpen(vfs, NULL, osFile, SQLITE_OPEN_READWRITE, &outFlags);
1.671 + if(err == SQLITE_OK)
1.672 + {
1.673 + //Since this is a temp file, its creation will be delayed till the first file write operation.
1.674 + err = sqlite3OsWrite(osFile, "1234", 4, 0);
1.675 + (void)sqlite3OsClose(osFile);
1.676 + }
1.677 + OomPostStep();
1.678 + if(err != SQLITE_OK)
1.679 + {
1.680 + TEST2(err, SQLITE_IOERR_NOMEM);
1.681 + }
1.682 + //If the iteration has failed, then no temp file should exist in the test private data cage.
1.683 + //If the iteration has succeeded, then sqlite3OsClose() should have deleted the temp file.
1.684 + TInt err2 = DoDeleteTempFiles();
1.685 + TEST2(err2, KErrNotFound);
1.686 + }
1.687 + TEST2(err, SQLITE_OK);
1.688 + TheTest.Printf(_L("\r\n=== TVfs::Open(<temp file>) OOM test succeeded at allcoation %d\r\n"), failingAllocNum);
1.689 +
1.690 + User::Free(osFile);
1.691 + }
1.692 +
1.693 +void VfsOpenTempFileFileIoErrTest()
1.694 + {
1.695 + //Delete all temp files in this test private data cage.
1.696 + TInt err = DoDeleteTempFiles();
1.697 + TEST(err == KErrNone || err == KErrNotFound);
1.698 +
1.699 + sqlite3_vfs* vfs = sqlite3_vfs_find(NULL);
1.700 + TEST(vfs != NULL);
1.701 +
1.702 + sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);
1.703 + TEST(osFile != NULL);
1.704 +
1.705 + err = SQLITE_ERROR;
1.706 + TInt cnt = 1;
1.707 + while(err != SQLITE_OK)
1.708 + {
1.709 + TInt processHandleCnt = 0;
1.710 + TInt threadHandleCnt = 0;
1.711 + RThread().HandleCount(processHandleCnt, threadHandleCnt);
1.712 + TInt allocCellsCnt = User::CountAllocCells();
1.713 +
1.714 + TheTest.Printf(_L("%d "), cnt);
1.715 + (void)TheFs.SetErrorCondition(KErrGeneral, cnt);
1.716 + int outFlags = 0;
1.717 + err = sqlite3OsOpen(vfs, NULL, osFile, SQLITE_OPEN_READWRITE, &outFlags);
1.718 + if(err == SQLITE_OK)
1.719 + {
1.720 + //Since this is a temp file, its creation will be delayed till the first file write operation.
1.721 + err = sqlite3OsWrite(osFile, "1234", 4, 0);
1.722 + (void)sqlite3OsClose(osFile);
1.723 + }
1.724 + (void)TheFs.SetErrorCondition(KErrNone);
1.725 + if(err != SQLITE_OK)
1.726 + {
1.727 + TInt processHandleCnt2 = 0;
1.728 + TInt threadHandleCnt2 = 0;
1.729 + RThread().HandleCount(processHandleCnt2, threadHandleCnt2);
1.730 + TEST2(processHandleCnt2, processHandleCnt);
1.731 + TEST2(threadHandleCnt2, threadHandleCnt);
1.732 + TInt allocCellsCnt2 = User::CountAllocCells();
1.733 + TEST2(allocCellsCnt2, allocCellsCnt);
1.734 + ++cnt;
1.735 + }
1.736 + //If the iteration has failed, then no temp file should exist in the test private data cage.
1.737 + //If the iteration has succeeded, then sqlite3OsClose() should have deleted the temp file.
1.738 + TInt err2 = DoDeleteTempFiles();
1.739 + TEST2(err2, KErrNotFound);
1.740 + }
1.741 + TEST2(err, SQLITE_OK);
1.742 + TheTest.Printf(_L("\r\n=== TVfs::Open(<temp file>) file I/O error simulation test succeeded at iteration %d\r\n"), cnt);
1.743 + User::Free(osFile);
1.744 + }
1.745 +
1.746 +void VfsCreateDeleteOnCloseFileOomTest()
1.747 + {
1.748 + sqlite3_vfs* vfs = sqlite3_vfs_find(NULL);
1.749 + TEST(vfs != NULL);
1.750 +
1.751 + sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);
1.752 + TEST(osFile != NULL);
1.753 +
1.754 + TheTest.Printf(_L("Iteration: "));
1.755 + TInt failingAllocNum = 0;
1.756 + TInt err = SQLITE_IOERR_NOMEM;
1.757 + while(err == SQLITE_IOERR_NOMEM)
1.758 + {
1.759 + ++failingAllocNum;
1.760 + TheTest.Printf(_L("%d "), failingAllocNum);
1.761 + OomPreStep(failingAllocNum);
1.762 + int outFlags = 0;
1.763 + err = sqlite3OsOpen(vfs, KTestFile4Z, osFile, SQLITE_OPEN_CREATE | SQLITE_OPEN_DELETEONCLOSE, &outFlags);
1.764 + if(err == SQLITE_OK)
1.765 + {
1.766 + err = sqlite3OsClose(osFile);
1.767 + }
1.768 + OomPostStep();
1.769 + if(err != SQLITE_OK)
1.770 + {
1.771 + TEST2(err, SQLITE_IOERR_NOMEM);
1.772 + }
1.773 + //Whether the iteration has failed or succeeded, the file should not exist.
1.774 + TPtrC8 ptrname((const TUint8*)KTestFile4Z);
1.775 + TBuf<50> fname;
1.776 + fname.Copy(ptrname);
1.777 + TInt err2 = TheFs.Delete(fname);
1.778 + TEST2(err2, KErrNotFound);
1.779 + }
1.780 + TEST2(err, SQLITE_OK);
1.781 + TheTest.Printf(_L("\r\n=== TVfs::Open(<delete on close file>) OOM test succeeded at allcoation %d\r\n"), failingAllocNum);
1.782 + User::Free(osFile);
1.783 + }
1.784 +
1.785 +///////////////////////////////////////////////////////////////////////////////////////
1.786 +
1.787 +//Panic thread function.
1.788 +//It will cast aData parameter to a TFunctor pointer and call it.
1.789 +//The expectation is that the called function will panic and kill the panic thread.
1.790 +TInt ThreadFunc(void* aData)
1.791 + {
1.792 + CTrapCleanup* tc = CTrapCleanup::New();
1.793 + TEST(tc != NULL);
1.794 +
1.795 + User::SetJustInTime(EFalse); // disable debugger panic handling
1.796 +
1.797 + TFunctor* obj = reinterpret_cast<TFunctor*> (aData);
1.798 + TEST(obj != NULL);
1.799 + (*obj)();//call the panic function
1.800 +
1.801 + delete tc;
1.802 +
1.803 + return KErrNone;
1.804 + }
1.805 +
1.806 +//Panic test.
1.807 +//PanicTest function will create a new thread - panic thread, giving it a pointer to the function which has to
1.808 +//be executed and the expectation is that the function will panic and kill the panic thread.
1.809 +//PanicTest function will check the panic thread exit code, exit category and the panic code.
1.810 +void PanicTest(TFunctor& aFunctor, TExitType aExpectedExitType, const TDesC& aExpectedCategory, TInt aExpectedPanicCode)
1.811 + {
1.812 + RThread thread;
1.813 + _LIT(KThreadName,"OsLayerPanicThread");
1.814 + TEST2(thread.Create(KThreadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&aFunctor, EOwnerThread), KErrNone);
1.815 +
1.816 + TRequestStatus status;
1.817 + thread.Logon(status);
1.818 + TEST2(status.Int(), KRequestPending);
1.819 + thread.Resume();
1.820 + User::WaitForRequest(status);
1.821 + User::SetJustInTime(ETrue); // enable debugger panic handling
1.822 +
1.823 + TEST2(thread.ExitType(), aExpectedExitType);
1.824 + TEST(thread.ExitCategory() == aExpectedCategory);
1.825 + TEST2(thread.ExitReason(), aExpectedPanicCode);
1.826 +
1.827 + CLOSE_AND_WAIT(thread);
1.828 + }
1.829 +
1.830 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.831 +////////////////////////////// Panic test functions /////////////////////////////////////////////////
1.832 +////////////////////////////////////////////////////////////////////////////////////////////////////////////
1.833 +
1.834 +#ifdef _DEBUG
1.835 +
1.836 +//Panic when calling COsLayerData::Create() is called and the OS layer data has been already created.
1.837 +class TOsLayerDataDuplicated : public TFunctor
1.838 + {
1.839 +private:
1.840 + virtual void operator()()
1.841 + {
1.842 + (void)sqlite3SymbianLibInit();//This should crash the thread in debug mode (because the Os layer
1.843 + //data was created already in TestEnvInit()).
1.844 + }
1.845 + };
1.846 +static TOsLayerDataDuplicated TheOsLayerDataDuplicated;
1.847 +
1.848 +#endif //_DEBUG
1.849 +
1.850 +/**
1.851 +@SYMTestCaseID SYSLIB-SQL-CT-1650
1.852 +@SYMTestCaseDesc SQL, OS porting layer tests.
1.853 +@SYMTestPriority High
1.854 +@SYMTestActions SQL, OS porting layer tests.
1.855 +@SYMTestExpectedResults Test must not fail
1.856 +@SYMREQ REQ5792
1.857 + REQ5793
1.858 +*/
1.859 +void DoTests()
1.860 + {
1.861 + TheTest.Printf(_L("OS porting layer test - create/open/close/delete a file\r\n"));
1.862 + Test1();
1.863 + TheTest.Printf(_L("OS porting layer test - read/write/seek/truncate\r\n"));
1.864 + Test2();
1.865 + TheTest.Printf(_L("OS porting layer test - miscellaneous tests\r\n"));
1.866 + Test3();
1.867 + TheTest.Printf(_L("OS porting layer test - lock/unlock\r\n"));
1.868 + Test5();
1.869 + TheTest.Printf(_L("OS porting layer test - sqlite3SymbianLibInit() - OOM test\r\n"));
1.870 + sqlite3SymbianLibInitOomTest();
1.871 + TheTest.Printf(_L("OS porting layer test - sqlite3SymbianLibInit() - 'File I/O error simulation' test\r\n"));
1.872 + sqlite3SymbianLibInitFsErrTest();
1.873 + TheTest.Printf(_L("OS porting layer test - 'profiler disabled' tests\r\n"));
1.874 + ProfilerDisabledTest();
1.875 + TheTest.Printf(_L("OS porting layer test - negative tests\r\n"));
1.876 + NegativeTest();
1.877 + TheTest.Printf(_L("TVfs::Open(<temp file>) OOM test\r\n"));
1.878 + VfsOpenTempFileOomTest();
1.879 + TheTest.Printf(_L("TVfs::Open(<temp file>) file I/O error simulation test\r\n"));
1.880 + VfsOpenTempFileFileIoErrTest();
1.881 + TheTest.Printf(_L("TVfs::Open(<'delete on close' file>) OOM test\r\n"));
1.882 + VfsCreateDeleteOnCloseFileOomTest();
1.883 +#ifdef _DEBUG
1.884 + TheTest.Printf(_L("'An attempt to create the OS layer data again' panic\r\n"));
1.885 + PanicTest(TheOsLayerDataDuplicated, EExitPanic, KSqlitePanicCategory, ESqliteOsPanicOsLayerDataExists);
1.886 +#endif //_DEBUG
1.887 + }
1.888 +
1.889 +TInt E32Main()
1.890 + {
1.891 + TheTest.Title();
1.892 +
1.893 + CTrapCleanup* tc = CTrapCleanup::New();
1.894 + TheTest(tc != NULL);
1.895 +
1.896 + __UHEAP_MARK;
1.897 +
1.898 + TestEnvInit();
1.899 + DeleteTestFiles();
1.900 + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1650 OS porting layer tests"));
1.901 + DoTests();
1.902 + TestEnvDestroy();
1.903 +
1.904 + __UHEAP_MARKEND;
1.905 +
1.906 + TheTest.End();
1.907 + TheTest.Close();
1.908 +
1.909 + delete tc;
1.910 +
1.911 + User::Heap().Check();
1.912 + return KErrNone;
1.913 + }