Symaptic: os/persistentdata/persistentstorage/sql/TEST/t

     1 // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include <e32test.h>

    17 #include <bautils.h>

    18 #include <stdlib.h>

    19 #include <string.h>

    20 #include <hal.h>

    21 #include "SqliteSymbian.h"

    22 #ifdef __cplusplus

    23 extern "C" {

    24 #endif

    25 	#include "sqliteInt.h"

    26 	#include "os.h"

    27 #ifdef __cplusplus

    28 }  /* End of the 'extern "C"' block */

    29 #endif

    30 #include "SqliteUtil.h"

    32 ///////////////////////////////////////////////////////////////////////////////////////

    34 const char* KSymbianVfsNameZ = "SymbianSql";

    36 RTest TheTest(_L("t_sqloslayer test"));

    37 RFs   TheFs;

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

    40 _LIT(KTestFile1, "c:\\test\\t_sqloslayer.bin");

    41 _LIT(KTestFile3, "c:\\test\\t_sqloslayer.db");

    42 const char* KTestFile1Z = "c:\\test\\t_sqloslayer.bin";

    43 const char* KTestFile2Z = "z:\\test\\TestDb1.db";

    44 const char* KTestFile3Z = "c:\\test\\t_sqloslayer.db";

    45 _LIT(KPrivateDir, "c:\\private\\21F12127\\");

    46 const char* KTestFile4Z = "c:\\test\\t_sqloslayer2.db";

    48 //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)

    49 #ifdef _SQLPROFILER

    50 TInt TheSqlSrvProfilerFileRead = 0;

    51 TInt TheSqlSrvProfilerFileWrite = 0;

    52 TInt TheSqlSrvProfilerFileSync = 0;

    53 TInt TheSqlSrvProfilerFileSetSize = 0;

    54 #endif

    56 #ifdef _DEBUG

    57 //SQLite panic category.

    58 _LIT(KSqlitePanicCategory, "Sqlite");

    59 #endif

    61 ///////////////////////////////////////////////////////////////////////////////////////

    63 void DeleteTestFiles()

    64 	{

    65 	(void)TheFs.Delete(KTestFile3);

    66 	(void)TheFs.Delete(KTestFile1);

    67 	}

    69 void TestEnvDestroy()

    70 	{

    71 	sqlite3SymbianLibFinalize();

    72 	DeleteTestFiles();

    73 	TheFs.Close();

    74 	}

    76 ///////////////////////////////////////////////////////////////////////////////////////

    77 ///////////////////////////////////////////////////////////////////////////////////////

    78 //Test macros and functions

    79 void Check1(TInt aValue, TInt aLine)

    80 	{

    81 	if(!aValue)

    82 		{

    83 		TestEnvDestroy();

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

    85 		TheTest(EFalse, aLine);

    86 		}

    87 	}

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

    89 	{

    90 	if(aValue != aExpected)

    91 		{

    92 		TestEnvDestroy();

    93 		RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);

    94 		TheTest(EFalse, aLine);

    95 		}

    96 	}

    97 #define TEST(arg) ::Check1((arg), __LINE__)

    98 #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)

   100 ///////////////////////////////////////////////////////////////////////////////////////

   102 static TInt TheProcessHandleCount = 0;

   103 static TInt TheThreadHandleCount = 0;

   104 static TInt TheAllocatedCellsCount = 0;

   106 #ifdef _DEBUG

   107 static const TInt KBurstRate = 20;

   108 #endif

   110 static void MarkHandles()

   111     {

   112     RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);

   113     }

   115 static void MarkAllocatedCells()

   116     {

   117     TheAllocatedCellsCount = User::CountAllocCells();

   118     }

   120 static void CheckAllocatedCells()

   121     {

   122     TInt allocatedCellsCount = User::CountAllocCells();

   123     TEST2(allocatedCellsCount, TheAllocatedCellsCount);

   124     }

   126 static void CheckHandles()

   127     {

   128     TInt endProcessHandleCount;

   129     TInt endThreadHandleCount;

   131     RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

   133     TEST2(TheProcessHandleCount, endProcessHandleCount);

   134     TEST2(TheThreadHandleCount, endThreadHandleCount);

   135     }

   137 static void OomPreStep(TInt

   138 #ifdef _DEBUG

   139     aFailingAllocationNo

   140 #endif

   141                       )

   142     {

   143     MarkHandles();

   144     MarkAllocatedCells();

   145     __UHEAP_MARK;

   146     __UHEAP_SETBURSTFAIL(RAllocator::EBurstFailNext, aFailingAllocationNo, KBurstRate);

   147     }

   149 static void OomPostStep()

   150     {

   151     __UHEAP_RESET;

   152     __UHEAP_MARKEND;

   153     CheckAllocatedCells();

   154     CheckHandles();

   155     }

   157 ///////////////////////////////////////////////////////////////////////////////////////

   159 void TestEnvInit()

   160     {

   161 	TInt err = TheFs.Connect();

   162 	TEST2(err, KErrNone);

   164 	err = TheFs.MkDir(KTestDir);

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

   167 	err = sqlite3SymbianLibInit();

   168 	TEST2(err, KErrNone);

   169 	}

   171 TInt CalcMs(TUint32 aStartTicks, TUint32 aEndTicks)

   172 	{

   173 	static TInt freq = 0;

   174 	if(freq == 0)

   175 		{

   176 		TEST2(HAL::Get(HAL::EFastCounterFrequency, freq), KErrNone);

   177 		}

   178 	TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;

   179 	if(diffTicks < 0)

   180 		{

   181 		diffTicks = KMaxTUint32 + diffTicks + 1;

   182 		}

   183 	const TInt KMicroSecIn1Sec = 1000000;

   184 	TInt32 us = (diffTicks * KMicroSecIn1Sec) / freq;

   185 	return us / 1000;

   186 	}

   188 ///////////////////////////////////////////////////////////////////////////////////////

   190 //Create/open/close/delete a file

   191 void Test1()

   192 	{

   193 	sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);

   194 	TEST(vfs != NULL);

   196   	sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);

   197 	TEST(osFile != NULL);

   199 	//Creating a new file

   200 	int outFlags = 0;

   201 	int err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, &outFlags);

   202 	TEST2(err, SQLITE_OK);

   203 	TEST(outFlags & SQLITE_OPEN_READWRITE);

   204 	err = sqlite3OsClose(osFile);

   205 	TEST2(err, SQLITE_OK);

   206 	//Opening an existing file for R/W

   207 	err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READWRITE, &outFlags);

   208 	TEST2(err, SQLITE_OK);

   209 	TEST(outFlags & SQLITE_OPEN_READWRITE);

   210 	err = sqlite3OsClose(osFile);

   211 	TEST2(err, SQLITE_OK);

   212 	//Opening a read-only file

   213 	err = sqlite3OsOpen(vfs, KTestFile2Z, osFile, SQLITE_OPEN_READWRITE, &outFlags);

   214 	TEST2(err, SQLITE_OK);

   215 	TEST(outFlags & SQLITE_OPEN_READONLY);

   216 	//Truncate a read-only file

   217 	err = osFile->pMethods->xTruncate(osFile, 0);

   218 	TEST2(err, SQLITE_IOERR);

   219 	//xAccess - read-only file

   220 	int res = 0;

   221 	err = vfs->xAccess(vfs, KTestFile2Z, SQLITE_ACCESS_READ, &res);

   222 	TEST2(err, SQLITE_OK);

   223 	TEST(res != 0);

   224 	//xAccess - invalid request

   225 	res = 0;

   226 	err = vfs->xAccess(vfs, KTestFile2Z, 122, &res);

   227 	TEST2(err, SQLITE_OK);

   228 	TEST2(res, 0);

   229 	//

   230 	err = sqlite3OsClose(osFile);

   231 	TEST2(err, SQLITE_OK);

   232 	//Creating a new file

   233 	err = sqlite3OsOpen(vfs, KTestFile3Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, &outFlags);

   234 	TEST2(err, SQLITE_OK);

   235 	TEST(outFlags & SQLITE_OPEN_READWRITE);

   236 	err = sqlite3OsClose(osFile);

   237 	TEST2(err, SQLITE_OK);

   238 	//Open a file for a read-only access

   239 	err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READONLY, &outFlags);

   240 	TEST2(err, SQLITE_OK);

   241 	TEST(outFlags & SQLITE_OPEN_READONLY);

   242 	err = sqlite3OsWrite(osFile, "1234", 4, 0);

   243 	TEST(err != SQLITE_OK);

   244 	err = sqlite3SymbianLastOsError();

   245 	TEST2(err, KErrAccessDenied);

   246 	err = vfs->xGetLastError(vfs, 0, 0);

   247 	TEST2(err, 0);//Default implementation

   248 	err = sqlite3OsClose(osFile);

   249 	TEST2(err, SQLITE_OK);

   250 	//Delete KTestFile3Z file

   251 	err = sqlite3OsDelete(vfs, KTestFile3Z, 0);

   252 	TEST2(err, SQLITE_OK);

   253 	res = 0;

   254 	err = sqlite3OsAccess(vfs, KTestFile3Z, SQLITE_ACCESS_EXISTS, &res);

   255 	TEST2(err, SQLITE_OK);

   256 	TEST2(res, 0);

   257 	//Open a file for an exclusive access

   258 	err = sqlite3OsOpen(vfs, KTestFile3Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_DELETEONCLOSE | SQLITE_OPEN_EXCLUSIVE, &outFlags);

   259 	TEST2(err, SQLITE_OK);

   260 	err = sqlite3OsClose(osFile);

   261 	TEST2(err, SQLITE_OK);

   262 	//The file should not exist now

   263 	err = sqlite3OsAccess(vfs, KTestFile3Z, SQLITE_ACCESS_EXISTS, &res);

   264 	TEST2(err, SQLITE_OK);

   265 	TEST2(res, 0);

   266 	//Open a file for an exclusive access without deleting it after

   267 	err = sqlite3OsOpen(vfs, KTestFile3Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_EXCLUSIVE, &outFlags);

   268 	TEST2(err, SQLITE_OK);

   269 	err = sqlite3OsClose(osFile);

   270 	TEST2(err, SQLITE_OK);

   271 	//The file should exist now

   272 	err = sqlite3OsAccess(vfs, KTestFile3Z, SQLITE_ACCESS_EXISTS, &res);

   273 	TEST2(err, SQLITE_OK);

   274 	TEST2(res, 1);

   275 	//Delete KTestFile3Z file

   276 	err = sqlite3OsDelete(vfs, KTestFile3Z, 0);

   277 	TEST2(err, SQLITE_OK);

   278 	err = sqlite3OsAccess(vfs, KTestFile3Z, SQLITE_ACCESS_EXISTS, &res);

   279 	TEST2(err, SQLITE_OK);

   280 	TEST2(res, 0);

   281 	//

   282 	User::Free(osFile);

   283 	}

   285 //Read/Write/Seek/Truncate test

   286 void Test2()

   287 	{

   288 	sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);

   289 	TEST(vfs != NULL);

   291   	sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);

   292 	TEST(osFile != NULL);

   294 	//Creating a new file

   295 	int err = sqlite3OsDelete(vfs, KTestFile1Z, 0);

   296 	TEST2(err, SQLITE_OK);

   297 	int res = 0;

   298 	err = sqlite3OsAccess(vfs, KTestFile1Z, SQLITE_ACCESS_EXISTS, &res);

   299 	TEST2(err, SQLITE_OK);

   300 	TEST2(res, 0);

   301 	err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);

   302 	TEST2(err, SQLITE_OK);

   303 	//Writing at the beginning of the file

   304 	err = sqlite3OsWrite(osFile, "123456", 6, 0);

   305 	TEST2(err, SQLITE_OK);

   306 	//Verify the written data

   307 	char data[20];

   308 	err = sqlite3OsRead(osFile, data, 6, 0);

   309 	TEST2(err, SQLITE_OK);

   310 	err = memcmp(data, "123456", 6);

   311 	TEST2(err, 0);

   312 	//Writing at beyond the end of the file

   313 	err = sqlite3OsWrite(osFile, "abcdefgh", 8, 100);

   314 	TEST2(err, SQLITE_OK);

   315 	//Verify the written data

   316 	err = sqlite3OsRead(osFile, data, 8, 100);

   317 	TEST2(err, SQLITE_OK);

   318 	err = memcmp(data, "abcdefgh", 8);

   319 	TEST2(err, 0);

   320 	//Truncate the file

   321 	err = sqlite3OsTruncate(osFile, 3);

   322 	TEST2(err, SQLITE_OK);

   323 	//Write more data

   324 	err = sqlite3OsWrite(osFile, "xyz", 3, 3);

   325 	TEST2(err, SQLITE_OK);

   326 	//Verify the written data

   327 	err = sqlite3OsRead(osFile, data, 6, 0);

   328 	TEST2(err, SQLITE_OK);

   329 	err = memcmp(data, "123xyz", 6);

   330 	TEST2(err, 0);

   331 	//Check the file size

   332 	TInt64 fileSize = 0;

   333 	err = sqlite3OsFileSize(osFile, &fileSize);

   334 	TEST2(err, SQLITE_OK);

   335 	TEST(fileSize == 6);

   336 	//FileControl - lock type

   337 	int lockType = -1;

   338 	err = osFile->pMethods->xFileControl(osFile, SQLITE_FCNTL_LOCKSTATE, &lockType);

   339 	TEST2(err, SQLITE_OK);

   340 	TEST2(lockType, NO_LOCK);

   341 	//FileControl - set callback - NULL callback

   342 	err = osFile->pMethods->xFileControl(osFile, KSqlFcntlRegisterFreePageCallback, 0);

   343 	TEST2(err, SQLITE_ERROR);

   344 	//FileControl - set callback - invalid callback object

   345 	TSqlFreePageCallback cbck;

   346 	err = osFile->pMethods->xFileControl(osFile, KSqlFcntlRegisterFreePageCallback, &cbck);

   347 	TEST2(err, SQLITE_ERROR);

   348 	//FileControl - invalid op-code

   349 	err = osFile->pMethods->xFileControl(osFile, 90234, 0);

   350 	TEST2(err, SQLITE_ERROR);

   351 	//Close the file

   352 	err = sqlite3OsClose(osFile);

   353 	TEST2(err, SQLITE_OK);

   354 	//

   355 	err = sqlite3OsDelete(vfs, KTestFile1Z, 0);

   356 	TEST2(err, SQLITE_OK);

   357 	User::Free(osFile);

   358 	}

   360 //Miscellaneous tests

   361 void Test3()

   362 	{

   363 	sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);

   364 	TEST(vfs != NULL);

   365 	//Full path name - the full file name is specified

   366 	char fname[KMaxFileName];

   367 	const char* testFileName1 = "c:\\test\\abv.db";

   368 	int err = sqlite3OsFullPathname(vfs, testFileName1, KMaxFileName, fname);

   369 	TEST2(err, SQLITE_OK);

   370 	err = strncasecmp(fname, testFileName1, strlen(testFileName1));

   371 	TEST2(err, 0);

   372 	//Full path name - no drive, the full file name is not specified

   373 	const char* testFileName2 = "abv.db";

   374 	const char* expectedFileName2 = "c:\\private\\21F12127\\abv.db";//"21F12127", the UID of the current test app

   375 	err = sqlite3OsFullPathname(vfs, testFileName2, KMaxFileName, fname);

   376 	TEST2(err, SQLITE_OK);

   377 	err = strncasecmp(fname, expectedFileName2, strlen(expectedFileName2));

   378 	TEST2(err, 0);

   379 	//Full path name - drive present, the full file name is not specified

   380 	const char* testFileName3 = "z:abv.db";

   381 	const char* expectedFileName3 = "z:\\private\\21F12127\\abv.db";//"21F12127", the UID of the current test app

   382 	err = sqlite3OsFullPathname(vfs, testFileName3, KMaxFileName, fname);

   383 	TEST2(err, SQLITE_OK);

   384 	err = strncasecmp(fname, expectedFileName3, strlen(expectedFileName3));

   385 	TEST2(err, 0);

   386 	//Is directory writable - test 1

   387 	int res = 0;

   388 	err = sqlite3OsAccess(vfs, "c:\\test", SQLITE_ACCESS_READWRITE, &res);

   389 	TEST2(err, SQLITE_OK);

   390 	TEST2(res, 1);

   391 	//Is directory writable - test 2

   392 	err = sqlite3OsAccess(vfs, "c:\\test\\", SQLITE_ACCESS_READWRITE, &res);

   393 	TEST2(err, SQLITE_OK);

   394 	TEST2(res, 1);

   395 	//Is directory writable - test 3

   396 	//Not a valid test. It is the media that's read only, not the directory.

   397 	//err = sqlite3OsAccess(vfs, "z:\\test\\", SQLITE_ACCESS_READWRITE, &res);

   398 	//TEST2(err, SQLITE_OK);

   399 	//TEST2(res, 0);

   400 	//Random seed

   401 	const int KBufLen = 100;

   402 	char buf[KBufLen];

   403 	err = sqlite3OsRandomness(vfs, KBufLen, buf);

   404 	TEST2(err, KBufLen);

   405 	//Sleep

   406 	TUint32 start = User::FastCounter();

   407 	const TInt KSleepTime = 200000;//us

   408 	(void)sqlite3OsSleep(vfs, KSleepTime);

   409 	TUint32 end = User::FastCounter();

   410 	TInt ms = CalcMs(start, end);

   411 	TheTest.Printf(_L(" === sqlite3OsSleep() time=%d ms\r\n"), ms);

   412 	//TEST(ms >= 80 && ms <= 320);// -60%..+60%

   413 	}

   415 //Lock/unlock tests

   416 void Test5()

   417 	{

   418 	sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);

   419 	TEST(vfs != NULL);

   421   	sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);

   422 	TEST(osFile != NULL);

   424 	//Creating a new file

   425 	int res = 0;

   426 	int err = sqlite3OsAccess(vfs, KTestFile1Z, SQLITE_ACCESS_EXISTS, &res);

   427 	TEST2(err, SQLITE_OK);

   428 	TEST2(res, 0);

   429 	err = sqlite3OsOpen(vfs, KTestFile1Z, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);

   430 	TEST2(err, SQLITE_OK);

   431 	//Lock/unlock

   432 	//SHARED_LOCK

   433 	err = sqlite3OsLock(osFile, SHARED_LOCK);

   434 	TEST2(err, SQLITE_OK);

   435 	err = sqlite3OsCheckReservedLock(osFile, &res);

   436 	TEST2(err, SQLITE_OK);

   437 	TEST2(res, 0);

   438 	//RESERVED_LOCK

   439 	err = sqlite3OsLock(osFile, RESERVED_LOCK);

   440 	TEST2(err, SQLITE_OK);

   441 	err = sqlite3OsCheckReservedLock(osFile, &res);

   442 	TEST2(err, SQLITE_OK);

   443 	TEST2(res, 1);

   444 	//PENDING_LOCK

   445 	err = sqlite3OsLock(osFile, PENDING_LOCK);

   446 	TEST2(err, SQLITE_OK);

   447 	//EXCLUSIVE_LOCK

   448 	err = sqlite3OsLock(osFile, EXCLUSIVE_LOCK);

   449 	TEST2(err, SQLITE_OK);

   450 	//back to SHARED_LOCK

   451 	err = sqlite3OsLock(osFile, SHARED_LOCK);

   452 	TEST2(err, SQLITE_OK);

   453 	//UNLOCK

   454 	err = sqlite3OsUnlock(osFile, NO_LOCK);

   455 	//Close the file

   456 	err = sqlite3OsClose(osFile);

   457 	TEST2(err, SQLITE_OK);

   458 	//

   459 	err = sqlite3OsDelete(vfs, KTestFile1Z, 0);

   460 	TEST2(err, SQLITE_OK);

   461 	User::Free(osFile);

   462 	}

   464 //sqlite3SymbianLibInit() - OOM test

   465 void sqlite3SymbianLibInitOomTest()

   466 	{

   467 	sqlite3SymbianLibFinalize();

   469 	TInt failingAllocNum = 0;

   470 	TInt err = KErrNoMemory;

   471 	while(err == KErrNoMemory)

   472 		{

   473 		OomPreStep(++failingAllocNum);

   474 		err = sqlite3SymbianLibInit();

   475         sqlite3SymbianLibFinalize();

   476         OomPostStep();

   477         if(err != KErrNoMemory)

   478             {

   479             TEST2(err, KErrNone);

   480             }

   481 		}

   482 	TEST2(err, KErrNone);

   483 	TheTest.Printf(_L("=== sqlite3SymbianLibInit() OOM test succeeded at allcoation %d\r\n"), failingAllocNum);

   484 	}

   486 //sqlite3SymbianLibInit() - 'File I/O error simulation' test

   487 void sqlite3SymbianLibInitFsErrTest()

   488 	{

   489 	sqlite3SymbianLibFinalize();

   491 	TInt sysDrive = static_cast<TInt>(RFs::GetSystemDrive());

   492 	TDriveUnit drvUnit(sysDrive);

   493 	TDriveName drvName = drvUnit.Name();

   495 	TFileName path;

   496 	TInt err = TheFs.PrivatePath(path);

   497 	TEST2(err, KErrNone);

   499 	TParse privDataCage;

   500 	err = privDataCage.Set(drvName, &path, 0);

   501 	TEST2(err, KErrNone);

   503 	err = KErrNotFound;

   504 	TInt cnt = 1;

   505 	for(;err<KErrNone;++cnt)

   506 		{

   507 		for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)

   508 			{

   509 			(void)TheFs.RmDir(privDataCage.FullName());

   511 			TInt processHandleCnt = 0;

   512 			TInt threadHandleCnt = 0;

   513 			RThread().HandleCount(processHandleCnt, threadHandleCnt);

   514 			TInt allocCellsCnt = User::CountAllocCells();

   516 			(void)TheFs.SetErrorCondition(fsError, cnt);

   517 			err = sqlite3SymbianLibInit();

   518 			(void)TheFs.SetErrorCondition(KErrNone);

   520 			if(err != KErrNone)

   521 				{

   522 				TInt processHandleCnt2 = 0;

   523 				TInt threadHandleCnt2 = 0;

   524 				RThread().HandleCount(processHandleCnt2, threadHandleCnt2);

   525 				TEST2(processHandleCnt2, processHandleCnt);

   526 				TEST2(threadHandleCnt2, threadHandleCnt);

   527 				TInt allocCellsCnt2 = User::CountAllocCells();

   528 				TEST2(allocCellsCnt2, allocCellsCnt);

   529 				}

   530 			else

   531 				{

   532 				sqlite3SymbianLibFinalize();

   533 				}

   534 			}

   535 		}

   536 	sqlite3SymbianLibFinalize();

   537 	TheTest.Printf(_L("=== sqlite3SymbianLibInit() 'File I/O error simulation' test succeeded at iteration %d\r\n"), cnt);

   538 	}

   540 //If _SQLPROFILER macro is not defined then all profiling PS porting layer functions should return KErrNotSupported.

   541 void ProfilerDisabledTest()

   542 	{

   543 #ifndef _SQLPROFILER

   544 	TInt err = sqlite3SymbianProfilerStart(0);

   545 	TEST2(err, KErrNotSupported);

   547 	err = sqlite3SymbianProfilerStop(0);

   548 	TEST2(err, KErrNotSupported);

   550 	err = sqlite3SymbianProfilerReset(0);

   551 	TEST2(err, KErrNotSupported);

   553 	TBuf8<1> res;

   554 	err = sqlite3SymbianProfilerQuery(0, res);

   555 	TEST2(err, KErrNotSupported);

   556 	res = res;

   557 #else

   558 	TheTest.Printf(_L("  The _SQLPROFILER macro is defined. The Profliling OS porting layer functions are tested in t_sqlapi2\r\n"));

   559 #endif

   560 	}

   562 void NegativeTest()

   563 	{

   564 	TInt err = sqlite3SymbianLibInit();

   565 	TEST2(err, KErrNone);

   567 	sqlite3_vfs* vfs = sqlite3_vfs_find(KSymbianVfsNameZ);

   568 	TEST(vfs != NULL);

   570   	sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);

   571 	TEST(osFile != NULL);

   573 	//Creating a new file - the name is too long

   574 	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";

   575 	int outFlags = 0;

   576 	err = sqlite3OsOpen(vfs, KLongFileNameZ, osFile, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, &outFlags);

   577 	TEST2(err, SQLITE_CANTOPEN);

   579 	//Open a file - the name contains the '|', but not at position 0 (private database - bad name)

   580 	const char* KBadFileNameZ = "c:\\test\\01|23456.bin";

   581 	err = sqlite3OsOpen(vfs, KBadFileNameZ, osFile, SQLITE_OPEN_READWRITE, &outFlags);

   582 	TEST2(err, SQLITE_CANTOPEN);

   584 	//FullPathName() - the output buffer is too small

   585 	const char* KFileNameZ = "c:\\test\\0123456.bin";

   586 	char buf[5];

   587 	err = vfs->xFullPathname(vfs, KFileNameZ, 5, buf);

   588 	TEST2(err, SQLITE_ERROR);

   590 	//FullPathName() - NULL output buffer

   591 	err = vfs->xFullPathname(vfs, KFileNameZ, 5, NULL);

   592 	TEST2(err, SQLITE_ERROR);

   594 	//FullPathName() - NULL file name

   595 	err = vfs->xFullPathname(vfs, NULL, 5, buf);

   596 	TEST2(err, SQLITE_ERROR);

   598 	//FullPathName() - the file name is too long

   599 	err = vfs->xFullPathname(vfs, KLongFileNameZ, 5, buf);

   600 	TEST2(err, SQLITE_ERROR);

   602 	//FullPathName() - NULL file name

   603 	err = vfs->xFullPathname(vfs, NULL, 5, buf);

   604 	TEST2(err, SQLITE_ERROR);

   606 	//Dellete file - NULL file name

   607 	err = vfs->xDelete(vfs, 0, 0);

   608 	TEST2(err, SQLITE_ERROR);

   610 	//Delete file - the output buffer for the unicode file name is too small

   611 	err = vfs->xDelete(vfs, KLongFileNameZ, 0);

   612 	TEST2(err, SQLITE_ERROR);

   614 	//Open file - NULL file name - this is a temp file name

   615 	err = sqlite3OsOpen(vfs, NULL, osFile, SQLITE_OPEN_READWRITE, &outFlags);

   616 	TEST2(err, SQLITE_OK);

   617 	err = osFile->pMethods->xClose(osFile);

   618 	TEST2(err, SQLITE_OK);

   620 	//xAccess - too long file name

   621 	int res = -1;

   622 	err = vfs->xAccess(vfs, KLongFileNameZ, SQLITE_ACCESS_EXISTS, &res);

   623 	TEST2(err, SQLITE_IOERR_ACCESS);

   625 	//xAccess - NULL file name

   626 	err = vfs->xAccess(vfs, 0, SQLITE_ACCESS_EXISTS, &res);

   627 	TEST2(err, SQLITE_IOERR_ACCESS);

   629 	User::Free(osFile);

   630 	}

   632 TInt DoDeleteTempFiles()

   633 	{

   634     CFileMan* fm = NULL;

   635     TRAPD(err, fm = CFileMan::NewL(TheFs));

   636     TEST2(err, KErrNone);

   637     TFileName path;

   638     path.Copy(KPrivateDir);

   639     path.Append(_L("temp\\"));

   640     path.Append(_L("*.$$$"));

   641     err = fm->Delete(path);

   642     delete fm;

   643     return err;

   644 	}

   646 void VfsOpenTempFileOomTest()

   647     {

   648     //Delete all temp files in this test private data cage.

   649 	TInt err = DoDeleteTempFiles();

   650     TEST(err == KErrNone || err == KErrNotFound);

   652     sqlite3_vfs* vfs = sqlite3_vfs_find(NULL);

   653     TEST(vfs != NULL);

   655     sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);

   656     TEST(osFile != NULL);

   658     TheTest.Printf(_L("Iteration: "));

   659     TInt failingAllocNum = 0;

   660     err = SQLITE_IOERR_NOMEM;

   661     while(err == SQLITE_IOERR_NOMEM)

   662         {

   663         ++failingAllocNum;

   664         TheTest.Printf(_L("%d "), failingAllocNum);

   665         OomPreStep(failingAllocNum);

   666         int outFlags = 0;

   667         err = sqlite3OsOpen(vfs, NULL, osFile, SQLITE_OPEN_READWRITE, &outFlags);

   668         if(err == SQLITE_OK)

   669             {

   670 			//Since this is a temp file, its creation will be delayed till the first file write operation.

   671 			err = sqlite3OsWrite(osFile, "1234", 4, 0);

   672 			(void)sqlite3OsClose(osFile);

   673             }

   674         OomPostStep();

   675         if(err != SQLITE_OK)

   676             {

   677             TEST2(err, SQLITE_IOERR_NOMEM);

   678             }

   679         //If the iteration has failed, then no temp file should exist in the test private data cage.

   680         //If the iteration has succeeded, then sqlite3OsClose() should have deleted the temp file.

   681         TInt err2 = DoDeleteTempFiles();

   682         TEST2(err2, KErrNotFound);

   683         }

   684     TEST2(err, SQLITE_OK);

   685     TheTest.Printf(_L("\r\n=== TVfs::Open(<temp file>) OOM test succeeded at allcoation %d\r\n"), failingAllocNum);

   687     User::Free(osFile);

   688     }

   690 void VfsOpenTempFileFileIoErrTest()

   691 	{

   692     //Delete all temp files in this test private data cage.

   693 	TInt err = DoDeleteTempFiles();

   694     TEST(err == KErrNone || err == KErrNotFound);

   696     sqlite3_vfs* vfs = sqlite3_vfs_find(NULL);

   697     TEST(vfs != NULL);

   699     sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);

   700     TEST(osFile != NULL);

   702 	err = SQLITE_ERROR;

   703 	TInt cnt = 1;

   704 	while(err != SQLITE_OK)

   705 		{

   706 		TInt processHandleCnt = 0;

   707 		TInt threadHandleCnt = 0;

   708 		RThread().HandleCount(processHandleCnt, threadHandleCnt);

   709 		TInt allocCellsCnt = User::CountAllocCells();

   711         TheTest.Printf(_L("%d "), cnt);

   712 		(void)TheFs.SetErrorCondition(KErrGeneral, cnt);

   713         int outFlags = 0;

   714         err = sqlite3OsOpen(vfs, NULL, osFile, SQLITE_OPEN_READWRITE, &outFlags);

   715         if(err == SQLITE_OK)

   716             {

   717 			//Since this is a temp file, its creation will be delayed till the first file write operation.

   718 			err = sqlite3OsWrite(osFile, "1234", 4, 0);

   719 			(void)sqlite3OsClose(osFile);

   720             }

   721 		(void)TheFs.SetErrorCondition(KErrNone);

   722 		if(err != SQLITE_OK)

   723 			{

   724 			TInt processHandleCnt2 = 0;

   725 			TInt threadHandleCnt2 = 0;

   726 			RThread().HandleCount(processHandleCnt2, threadHandleCnt2);

   727 			TEST2(processHandleCnt2, processHandleCnt);

   728 			TEST2(threadHandleCnt2, threadHandleCnt);

   729 			TInt allocCellsCnt2 = User::CountAllocCells();

   730 			TEST2(allocCellsCnt2, allocCellsCnt);

   731 	        ++cnt;

   732 			}

   733         //If the iteration has failed, then no temp file should exist in the test private data cage.

   734         //If the iteration has succeeded, then sqlite3OsClose() should have deleted the temp file.

   735         TInt err2 = DoDeleteTempFiles();

   736         TEST2(err2, KErrNotFound);

   737 		}

   738     TEST2(err, SQLITE_OK);

   739     TheTest.Printf(_L("\r\n=== TVfs::Open(<temp file>) file I/O error simulation test succeeded at iteration %d\r\n"), cnt);

   740     User::Free(osFile);

   741 	}

   743 void VfsCreateDeleteOnCloseFileOomTest()

   744     {

   745     sqlite3_vfs* vfs = sqlite3_vfs_find(NULL);

   746     TEST(vfs != NULL);

   748     sqlite3_file* osFile = (sqlite3_file*)User::Alloc(vfs->szOsFile);

   749     TEST(osFile != NULL);

   751     TheTest.Printf(_L("Iteration: "));

   752     TInt failingAllocNum = 0;

   753     TInt err = SQLITE_IOERR_NOMEM;

   754     while(err == SQLITE_IOERR_NOMEM)

   755         {

   756         ++failingAllocNum;

   757         TheTest.Printf(_L("%d "), failingAllocNum);

   758         OomPreStep(failingAllocNum);

   759         int outFlags = 0;

   760         err = sqlite3OsOpen(vfs, KTestFile4Z, osFile, SQLITE_OPEN_CREATE | SQLITE_OPEN_DELETEONCLOSE, &outFlags);

   761         if(err == SQLITE_OK)

   762             {

   763             err = sqlite3OsClose(osFile);

   764             }

   765         OomPostStep();

   766         if(err != SQLITE_OK)

   767             {

   768             TEST2(err, SQLITE_IOERR_NOMEM);

   769             }

   770         //Whether the iteration has failed or succeeded, the file should not exist.

   771         TPtrC8 ptrname((const TUint8*)KTestFile4Z);

   772         TBuf<50> fname;

   773         fname.Copy(ptrname);

   774         TInt err2 = TheFs.Delete(fname);

   775         TEST2(err2, KErrNotFound);

   776         }

   777     TEST2(err, SQLITE_OK);

   778     TheTest.Printf(_L("\r\n=== TVfs::Open(<delete on close file>) OOM test succeeded at allcoation %d\r\n"), failingAllocNum);

   779     User::Free(osFile);

   780     }

   782 ///////////////////////////////////////////////////////////////////////////////////////

   784 //Panic thread function.

   785 //It will cast aData parameter to a TFunctor pointer and call it.

   786 //The expectation is that the called function will panic and kill the panic thread.

   787 TInt ThreadFunc(void* aData)

   788 	{

   789 	CTrapCleanup* tc = CTrapCleanup::New();

   790 	TEST(tc != NULL);

   792 	User::SetJustInTime(EFalse);	// disable debugger panic handling

   794 	TFunctor* obj = reinterpret_cast<TFunctor*> (aData);

   795 	TEST(obj != NULL);

   796 	(*obj)();//call the panic function

   798 	delete tc;

   800 	return KErrNone;

   801 	}

   803 //Panic test.

   804 //PanicTest function will create a new thread - panic thread, giving it a pointer to the function which has to

   805 //be executed and the expectation is that the function will panic and kill the panic thread.

   806 //PanicTest function will check the panic thread exit code, exit category and the panic code.

   807 void PanicTest(TFunctor& aFunctor, TExitType aExpectedExitType, const TDesC& aExpectedCategory, TInt aExpectedPanicCode)

   808 	{

   809 	RThread thread;

   810 	_LIT(KThreadName,"OsLayerPanicThread");

   811 	TEST2(thread.Create(KThreadName, &ThreadFunc, 0x2000, 0x1000, 0x10000, (void*)&aFunctor, EOwnerThread), KErrNone);

   813 	TRequestStatus status;

   814 	thread.Logon(status);

   815 	TEST2(status.Int(), KRequestPending);

   816 	thread.Resume();

   817 	User::WaitForRequest(status);

   818 	User::SetJustInTime(ETrue);	// enable debugger panic handling

   820 	TEST2(thread.ExitType(), aExpectedExitType);

   821 	TEST(thread.ExitCategory() == aExpectedCategory);

   822 	TEST2(thread.ExitReason(), aExpectedPanicCode);

   824 	CLOSE_AND_WAIT(thread);

   825 	}

   827 ////////////////////////////////////////////////////////////////////////////////////////////////////////////

   828 //////////////////////////////     Panic test functions    /////////////////////////////////////////////////

   829 ////////////////////////////////////////////////////////////////////////////////////////////////////////////

   831 #ifdef _DEBUG

   833 //Panic when calling COsLayerData::Create() is called and the OS layer data has been already created.

   834 class TOsLayerDataDuplicated : public TFunctor

   835 	{

   836 private:

   837 	virtual void operator()()

   838 		{

   839 		(void)sqlite3SymbianLibInit();//This should crash the thread in debug mode (because the Os layer

   840 		                              //data was created already in TestEnvInit()).

   841 		}

   842 	};

   843 static TOsLayerDataDuplicated TheOsLayerDataDuplicated;

   845 #endif //_DEBUG

   847 /**

   848 @SYMTestCaseID			SYSLIB-SQL-CT-1650

   849 @SYMTestCaseDesc		SQL, OS porting layer tests.

   850 @SYMTestPriority		High

   851 @SYMTestActions			SQL, OS porting layer tests.

   852 @SYMTestExpectedResults Test must not fail

   853 @SYMREQ					REQ5792

   854                         REQ5793

   855 */

   856 void DoTests()

   857 	{

   858 	TheTest.Printf(_L("OS porting layer test - create/open/close/delete a file\r\n"));

   859 	Test1();

   860 	TheTest.Printf(_L("OS porting layer test - read/write/seek/truncate\r\n"));

   861 	Test2();

   862 	TheTest.Printf(_L("OS porting layer test - miscellaneous tests\r\n"));

   863 	Test3();

   864 	TheTest.Printf(_L("OS porting layer test - lock/unlock\r\n"));

   865 	Test5();

   866 	TheTest.Printf(_L("OS porting layer test - sqlite3SymbianLibInit() - OOM test\r\n"));

   867 	sqlite3SymbianLibInitOomTest();

   868 	TheTest.Printf(_L("OS porting layer test - sqlite3SymbianLibInit() - 'File I/O error simulation' test\r\n"));

   869 	sqlite3SymbianLibInitFsErrTest();

   870 	TheTest.Printf(_L("OS porting layer test - 'profiler disabled' tests\r\n"));

   871 	ProfilerDisabledTest();

   872 	TheTest.Printf(_L("OS porting layer test - negative tests\r\n"));

   873 	NegativeTest();

   874     TheTest.Printf(_L("TVfs::Open(<temp file>) OOM test\r\n"));

   875     VfsOpenTempFileOomTest();

   876     TheTest.Printf(_L("TVfs::Open(<temp file>) file I/O error simulation test\r\n"));

   877     VfsOpenTempFileFileIoErrTest();

   878     TheTest.Printf(_L("TVfs::Open(<'delete on close' file>) OOM test\r\n"));

   879     VfsCreateDeleteOnCloseFileOomTest();

   880 #ifdef _DEBUG

   881 	TheTest.Printf(_L("'An attempt to create the OS layer data again' panic\r\n"));

   882 	PanicTest(TheOsLayerDataDuplicated, EExitPanic, KSqlitePanicCategory, ESqliteOsPanicOsLayerDataExists);

   883 #endif //_DEBUG

   884 	}

   886 TInt E32Main()

   887 	{

   888 	TheTest.Title();

   890 	CTrapCleanup* tc = CTrapCleanup::New();

   891 	TheTest(tc != NULL);

   893 	__UHEAP_MARK;

   895 	TestEnvInit();

   896 	DeleteTestFiles();

   897 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-1650 OS porting layer tests"));

   898 	DoTests();

   899 	TestEnvDestroy();

   901 	__UHEAP_MARKEND;

   903 	TheTest.End();

   904 	TheTest.Close();

   906 	delete tc;

   908 	User::Heap().Check();

   909 	return KErrNone;

   910 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--