sl@0: // Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include <e32test.h>
sl@0: #include <bautils.h>
sl@0: #include <sqldb.h>
sl@0: #include <stdio.h>
sl@0: #include <stdlib.h>
sl@0: #include <string.h> 
sl@0: #include "sqlite3.h"
sl@0: #include "SqliteSymbian.h"
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: RTest TheTest(_L("t_sqlfserr test"));
sl@0: _LIT(KTestDir, "c:\\test\\");
sl@0: _LIT(KTestDbName, "c:\\test\\t_fserr.db");
sl@0: _LIT(KPrivateTestDbName, "c:\\private\\212A2C27\\t_fserr2.db");
sl@0: _LIT(KSecureTestDbName, "c:[212A2C27]t_fserr3.db");
sl@0: 
sl@0: TFileName TheRmvMediaDbFileName;//The name of the file used for tests on a removable media
sl@0: RFs TheFs;
sl@0: RSqlDatabase TheDb;
sl@0: 
sl@0: //The next constants are used in the "blob write" test
sl@0: const TInt KWriteCnt = 9;
sl@0: const TInt KBlobSize = 397 * KWriteCnt;
sl@0: _LIT(KAttachDb, "AttachDb");
sl@0: 
sl@0: //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)
sl@0: #ifdef _SQLPROFILER
sl@0: TInt TheSqlSrvProfilerFileRead = 0;
sl@0: TInt TheSqlSrvProfilerFileWrite = 0;
sl@0: TInt TheSqlSrvProfilerFileSync = 0;
sl@0: TInt TheSqlSrvProfilerFileSetSize = 0;
sl@0: #endif
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: TBool FileExists(const TDesC& aFileName)
sl@0: 	{
sl@0: 	TEntry entry;
sl@0: 	return TheFs.Entry(aFileName, entry) == KErrNone;
sl@0: 	}
sl@0: 
sl@0: void DestroyTestEnv()
sl@0: 	{
sl@0: 	TheDb.Close();
sl@0:     (void)RSqlDatabase::Delete(KSecureTestDbName);
sl@0:     (void)RSqlDatabase::Delete(KPrivateTestDbName);
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	(void)RSqlDatabase::Delete(TheRmvMediaDbFileName);
sl@0: 	TheFs.Close();
sl@0: 	sqlite3SymbianLibFinalize();
sl@0: 	CloseSTDLIB();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Test macros and functions
sl@0: void Check(TInt aValue, TInt aLine)
sl@0: 	{
sl@0: 	if(!aValue)
sl@0: 		{
sl@0: 		DestroyTestEnv();
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: void Check(TInt aValue, TInt aExpected, TInt aLine)
sl@0: 	{
sl@0: 	if(aValue != aExpected)
sl@0: 		{
sl@0: 		DestroyTestEnv();
sl@0: 		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: #define TEST(arg) ::Check((arg), __LINE__)
sl@0: #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
sl@0: 
sl@0: void SqliteCheck(sqlite3* aDbHandle, TInt aValue, TInt aExpected, TInt aLine)
sl@0: 	{
sl@0: 	if(aValue != aExpected)
sl@0: 		{
sl@0: 		RDebug::Print(_L("*** SQLITE: Expected error: %d, got: %d\r\n"), aExpected, aValue);
sl@0: 		if(aDbHandle)
sl@0: 			{
sl@0: 			const char* errMsg = sqlite3_errmsg(aDbHandle);
sl@0: 			TPtrC8 ptr8((const TUint8*)errMsg, strlen(errMsg));
sl@0: 			TBuf<200> buf;
sl@0: 			buf.Copy(ptr8);
sl@0: 			RDebug::Print(_L("*** SQLITE error message: \"%S\"\r\n"), &buf);
sl@0: 			}
sl@0: 		DestroyTestEnv();
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: #define SQLITE_TEST(aDbHandle, aValue, aExpected) ::SqliteCheck(aDbHandle, aValue, aExpected, __LINE__)
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void SetupTestEnv()
sl@0:     {
sl@0: 	TInt err = TheFs.Connect();
sl@0: 	TEST2(err, KErrNone);
sl@0: 
sl@0: 	err = TheFs.MkDir(KTestDir);
sl@0: 	TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0: 
sl@0: 	sqlite3SymbianLibInit();
sl@0: 	}
sl@0: 
sl@0: TBool CheckRecord(const TDesC& aDbName, TInt aId, const TDesC& aExpectedName, TBool aOpenDb = ETrue)
sl@0: 	{
sl@0: 	if(aOpenDb)
sl@0: 		{
sl@0: 		TEST2(TheDb.Open(aDbName), KErrNone);
sl@0: 		}
sl@0: 	TBuf<64> sql;
sl@0: 	sql.Copy(_L("SELECT Name FROM A WHERE Id="));
sl@0: 	sql.AppendNum(aId);
sl@0: 	TSqlScalarFullSelectQuery q(TheDb);
sl@0: 	TBuf<20> name;
sl@0: 	TRAPD(err, (void)q.SelectTextL(sql, name));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	if(aOpenDb)
sl@0: 		{
sl@0: 		TheDb.Close();
sl@0: 		}
sl@0: 	return name == aExpectedName;
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-3419
sl@0: @SYMTestCaseDesc		Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
sl@0: 						The test creates a test database with one table, inserts one record.
sl@0: 						Then the test attempts to update the existing record while simulating file I/O failures.
sl@0: 						After each test iteration the database content is tested and is expected to be the same
sl@0: 						as it was before the test. RSqlDatabase::Exec() is used for the update operation.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMDEF					DEF103859
sl@0: */
sl@0: void AlterDatabaseTest()
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	TInt err = TheDb.Create(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
sl@0: 	TEST(err >= 0);
sl@0: 	TheDb.Close();
sl@0: 	err = KErrNotFound;
sl@0: 	for(TInt cnt=0;err<KErrNone;++cnt)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("%d \r"), cnt);		
sl@0: 		for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
sl@0: 			{
sl@0: 			//Preprocessing
sl@0: 			TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 			(void)TheDb.Exec(_L("DELETE FROM A WHERE Id=1"));
sl@0: 			err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
sl@0: 			TEST2(err, 1);
sl@0: 			//The test
sl@0: 			(void)TheFs.SetErrorCondition(fsError, cnt);
sl@0: 			err = TheDb.Exec(_L("UPDATE A SET Name='Name2' WHERE Id=1"));
sl@0: 			(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 			if(err < 1)
sl@0: 				{
sl@0: 				TheDb.Close();//close the database to recover from the last error
sl@0: 				//check the database content - all bets are off in a case of an I/O error. 
sl@0: 				//The existing record might have been updated.
sl@0: 				TEST(CheckRecord(KTestDbName, 1, _L("Name")) || CheckRecord(KTestDbName, 1, _L("Name2")));
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				TEST2(err, 1);
sl@0: 				//check the database content has been modified by the operation. 
sl@0: 				TEST(CheckRecord(KTestDbName, 1, _L("Name2"), EFalse));
sl@0: 				TheDb.Close();
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 	TEST2(err, 1);
sl@0: 	//check the database content (transaction durability). 
sl@0: 	TEST(CheckRecord(KTestDbName, 1, _L("Name2")));
sl@0: 	err = RSqlDatabase::Delete(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("\r\n"));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-3420
sl@0: @SYMTestCaseDesc		Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
sl@0: 						The test creates a test database with one table, inserts one record.
sl@0: 						Then the test attempts to update the existing record while simulating file I/O failures.
sl@0: 						After each test iteration the database content is tested and is expected to be the same
sl@0: 						as it was before the test. RSqlStatement::Exec() is used for the update operation.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMDEF					DEF103859
sl@0: */
sl@0: void AlterDatabaseTest2()
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	TInt err = TheDb.Create(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
sl@0: 	TEST(err >= 0);
sl@0: 	TheDb.Close();
sl@0: 	err = KErrNotFound;
sl@0: 	for(TInt cnt=0;err<KErrNone;++cnt)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("%d \r"), cnt);		
sl@0: 		for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
sl@0: 			{
sl@0: 			//Preprocessing
sl@0: 			TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 			(void)TheDb.Exec(_L("DELETE FROM A WHERE Id=1"));
sl@0: 			err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
sl@0: 			TEST2(err, 1);
sl@0: 			//The test
sl@0: 			(void)TheFs.SetErrorCondition(fsError, cnt);
sl@0: 			RSqlStatement stmt;
sl@0: 			err = stmt.Prepare(TheDb, _L("UPDATE A SET Name='Name2' WHERE Id=1"));
sl@0: 			if(err == KErrNone)
sl@0: 				{
sl@0: 				err = stmt.Exec();	
sl@0: 				}
sl@0: 			(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 			stmt.Close();
sl@0: 			if(err < 1)
sl@0: 				{
sl@0: 				TheDb.Close();//close the database to recover from the last error
sl@0: 				//check the database content - all bets are off in a case of an I/O error. 
sl@0: 				//The existing record might have been updated.
sl@0: 				TEST(CheckRecord(KTestDbName, 1, _L("Name")) || CheckRecord(KTestDbName, 1, _L("Name2")));
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				TEST2(err, 1);
sl@0: 				//check the database content has been modified by the operation. 
sl@0: 				TEST(CheckRecord(KTestDbName, 1, _L("Name2"), EFalse));
sl@0: 				TheDb.Close();
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 	TEST2(err, 1);
sl@0: 	//check the database content has been modified by the operation. 
sl@0: 	TEST(CheckRecord(KTestDbName, 1, _L("Name2")));
sl@0: 	err = RSqlDatabase::Delete(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("\r\n"));
sl@0: 	}
sl@0: 
sl@0: void CreateTestSecurityPolicy(RSqlSecurityPolicy& aSecurityPolicy)
sl@0:     {
sl@0:     TSecurityPolicy alwaysPassPolicy(TSecurityPolicy::EAlwaysPass);
sl@0:     TInt err = aSecurityPolicy.Create(alwaysPassPolicy);
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     err = aSecurityPolicy.SetDbPolicy(RSqlSecurityPolicy::ESchemaPolicy, alwaysPassPolicy);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = aSecurityPolicy.SetDbPolicy(RSqlSecurityPolicy::EWritePolicy, alwaysPassPolicy);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = aSecurityPolicy.SetDbPolicy(RSqlSecurityPolicy::EReadPolicy, alwaysPassPolicy);
sl@0:     TEST2(err, KErrNone);
sl@0:     }
sl@0: 
sl@0: //Creates public shared, private secure and public secure databases.
sl@0: void DoCreateTestDatabases(const TPtrC aDbName[], TInt aCount)
sl@0:     {
sl@0:     TEST(aCount > 0);
sl@0:     for(TInt i=0;i<aCount;++i)
sl@0:         {
sl@0:         TheTest.Printf(_L("Database: \"%S\"\r\n"), &aDbName[i]);       
sl@0:         (void)RSqlDatabase::Delete(aDbName[i]);
sl@0:         TInt err = KErrGeneral;
sl@0:         if(i == (aCount - 1))
sl@0:             {
sl@0:             RSqlSecurityPolicy policy;
sl@0:             CreateTestSecurityPolicy(policy);
sl@0:             err = TheDb.Create(aDbName[i], policy);
sl@0:             policy.Close();
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             err = TheDb.Create(aDbName[i]);
sl@0:             }
sl@0:         TEST2(err, KErrNone);
sl@0:         err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
sl@0:         TEST(err >= 0);
sl@0:         err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
sl@0:         TEST2(err, 1);
sl@0:         TheDb.Close();
sl@0:         }
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-3421
sl@0: @SYMTestCaseDesc		Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
sl@0: 						The test creates a test database with one table, inserts one record.
sl@0: 						Then the test attempts to open the database while simulating file I/O failures.
sl@0: 						At the end of the test the database content is tested and is expected to be the same
sl@0: 						as it was before the test. RSqlStatement::Open() is used in the test.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMDEF					DEF103859
sl@0: */
sl@0: void OpenDatabaseTest()
sl@0: 	{
sl@0:     TPtrC dbName[] = {KTestDbName(), KPrivateTestDbName(), KSecureTestDbName()};
sl@0:     const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
sl@0:     DoCreateTestDatabases(dbName, KDbNameCnt);
sl@0:     for(TInt k=0;k<KDbNameCnt;++k)
sl@0:         {	
sl@0:         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
sl@0:         TInt err = KErrNotFound;
sl@0:         for(TInt cnt=0;err<KErrNone;++cnt)
sl@0:             {		
sl@0:             TheTest.Printf(_L("%d \r"), cnt);		
sl@0:             for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
sl@0:                 {
sl@0:                 (void)TheFs.SetErrorCondition(fsError, cnt);
sl@0:                 err = TheDb.Open(dbName[k]);
sl@0:                 (void)TheFs.SetErrorCondition(KErrNone);
sl@0:                 if(err != KErrNone)
sl@0:                     {
sl@0:                     TheDb.Close();//close the database to recover from the last error
sl@0:                     //check the database content is still the same as before the "open" call
sl@0:                     TEST(CheckRecord(dbName[k], 1, _L("Name")));
sl@0:                     }
sl@0:                 else
sl@0:                     {
sl@0:                     TEST2(err, KErrNone);
sl@0:                     //check the database content is still the same as before the operation, without closing the database
sl@0:                     TEST(CheckRecord(dbName[k], 1, _L("Name"), EFalse));
sl@0:                     TheDb.Close();
sl@0:                     }
sl@0:                 }
sl@0:             }
sl@0:         (void)TheFs.SetErrorCondition(KErrNone);
sl@0:         TEST2(err, KErrNone);
sl@0:         //check the database content is the same as before the operation, after reopening the database.
sl@0:         TEST(CheckRecord(dbName[k], 1, _L("Name")));
sl@0:         err = RSqlDatabase::Delete(dbName[k]);
sl@0:         TEST2(err, KErrNone);
sl@0:         TheTest.Printf(_L("\r\n"));
sl@0:         }//end of: for(TInt k=0;k<KDbNameCnt;++k)
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-3434
sl@0: @SYMTestCaseDesc		Test for DEF104820 "SQL, RSqlDatabase::Create() does not delete the file if fails".
sl@0: 						Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
sl@0: 						Then the test attempts to create a database while simulating file I/O failures.
sl@0: 						When the test succeeds, the test verifies that the database file does exist.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Test for DEF104820 "SQL, RSqlDatabase::Create() does not delete the file if fails".
sl@0: 						Test for DEF103859 "SQLITE panic, _DEBUG mode, persistent file I/O error simulation".
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMDEF					DEF103859
sl@0: */
sl@0: void CreateDatabaseTest()
sl@0: 	{
sl@0: 	RSqlSecurityPolicy policy;
sl@0: 	CreateTestSecurityPolicy(policy);
sl@0: 	
sl@0: 	TPtrC dbName[] = {KTestDbName(), KPrivateTestDbName(), KSecureTestDbName()};
sl@0: 	const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
sl@0: 	for(TInt k=0;k<KDbNameCnt;++k)
sl@0: 	    {
sl@0:         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
sl@0:         TInt err = -1;
sl@0:         for(TInt cnt=0;err<KErrNone;++cnt)
sl@0:             {		
sl@0:             TheTest.Printf(_L("%d \r"), cnt);		
sl@0:             for (TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
sl@0:                 {
sl@0:                 //Ideally, the database should be deleted by the SQL server, if RSqlDatabase::Create() fails.
sl@0:                 //But SetErrorCondition() makes the error persistent, so the SQL server will fail to delete the file.
sl@0:                 //This is the reason, RSqlDatabase::Delete()to be used, before simulating file I/O error.
sl@0:                 (void)RSqlDatabase::Delete(dbName[k]);
sl@0:                 (void)TheFs.SetErrorCondition(fsError, cnt);
sl@0:                 err = (k == (KDbNameCnt - 1)) ? TheDb.Create(dbName[k], policy) : TheDb.Create(dbName[k]);
sl@0:                 (void)TheFs.SetErrorCondition(KErrNone);
sl@0:                 TheDb.Close();
sl@0:                 //If err != KErrNone, the database file should have been already deleted by the server and here is 
sl@0:                 //the place to check that. But since the file I/O failure simulation makes the file I/O error 
sl@0:                 //persistent, the file cannot be deleted by the server, because the "file delete" operation also fails.
sl@0:                 }
sl@0:             }
sl@0:         (void)TheFs.SetErrorCondition(KErrNone);
sl@0:         TheDb.Close();
sl@0:         TEST2(err, KErrNone);
sl@0:         if( k != (KDbNameCnt - 1))
sl@0:             {
sl@0:             TEST(FileExists(dbName[k]));
sl@0:             }
sl@0:         err = RSqlDatabase::Delete(dbName[k]);
sl@0:         TEST2(err, KErrNone);
sl@0:         TheTest.Printf(_L("\r\n"));
sl@0: 	    }
sl@0: 	policy.Close();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-UT-4189
sl@0: @SYMTestCaseDesc        Test for DEF145125 "SQL, low code coverage".
sl@0:                         The test creates public shared, private secure and public secure test databases.
sl@0:                         Then the test opens the publich shared database and attempts to attach one of the other two
sl@0:                         in a file I/O error simulation loop.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         Test for DEF145125 - "SQL, low code coverage".
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMDEF                 DEF145125 
sl@0: */
sl@0: void AttachDatabaseTest()
sl@0:     {
sl@0:     TPtrC dbName[] = {KTestDbName(), KPrivateTestDbName(), KSecureTestDbName()};
sl@0:     const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
sl@0:     DoCreateTestDatabases(dbName, KDbNameCnt);
sl@0:     for(TInt k=1;k<KDbNameCnt;++k)
sl@0:         {
sl@0:         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
sl@0:         TInt err = KErrGeneral;
sl@0:         for(TInt cnt=0;err<KErrNone;++cnt)
sl@0:             {
sl@0:             TheTest.Printf(_L("%d \r"), cnt);       
sl@0:             for(TInt fsError=KErrNotFound;fsError>=KErrDied;--fsError)
sl@0:                 {
sl@0:                 err = TheDb.Open(KTestDbName);
sl@0:                 TEST2(err, KErrNone);
sl@0:                 (void)TheFs.SetErrorCondition(fsError, cnt);
sl@0:                 err = TheDb.Attach(dbName[k], _L("DB2"));
sl@0:                 (void)TheFs.SetErrorCondition(KErrNone);
sl@0:                 (void)TheDb.Detach(_L("DB2"));
sl@0:                 TheDb.Close();//close the database to recover from the last error
sl@0:                 }
sl@0:             }
sl@0:         TEST2(err, KErrNone);
sl@0:         err = RSqlDatabase::Delete(dbName[k]);
sl@0:         TEST2(err, KErrNone);
sl@0:         TheTest.Printf(_L("\r\n"));
sl@0:         }
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-UT-4190
sl@0: @SYMTestCaseDesc        Test for DEF145125 "SQL, low code coverage".
sl@0:                         The tests attempts to delete a database in a file I/O error simulation loop.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         Test for DEF145125 - "SQL, low code coverage".
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMDEF                 DEF145125 
sl@0: */
sl@0: void DeleteDatabaseTest()
sl@0:     {
sl@0:     TPtrC dbName[] = {KTestDbName(), KPrivateTestDbName(), KSecureTestDbName()};
sl@0:     const TInt KDbNameCnt = sizeof(dbName) / sizeof(dbName[0]);
sl@0:     DoCreateTestDatabases(dbName, KDbNameCnt);
sl@0:     for(TInt k=0;k<KDbNameCnt;++k)
sl@0:         {   
sl@0:         TheTest.Printf(_L("Database: \"%S\"\r\n"), &dbName[k]);       
sl@0:         TInt err = KErrGeneral;
sl@0:         for(TInt cnt=1;err<KErrNone;++cnt)
sl@0:             {
sl@0:             TheTest.Printf(_L("%d \r"), cnt);
sl@0:             (void)TheFs.SetErrorCondition(KErrGeneral, cnt);
sl@0:             err = RSqlDatabase::Delete(dbName[k]);
sl@0:             (void)TheFs.SetErrorCondition(KErrNone);
sl@0:             }
sl@0:         TEST2(err, KErrNone);
sl@0:         err = RSqlDatabase::Delete(KTestDbName);
sl@0:         TEST2(err, KErrNotFound);
sl@0:         }    
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-3462
sl@0: @SYMTestCaseDesc		Test for DEF105434 "SQL, persistent file I/O simulation, COMMIT problem".
sl@0: 						The test creates a test database with one table, inserts one record.
sl@0: 						Then the test attempts to retrieve the existing record while simulating file I/O failures.
sl@0: 						After each iteration, the database content is tested, that it has not been modified by the operation.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Test for DEF105434 "SQL, persistent file I/O simulation, COMMIT problem".
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMDEF					DEF105434
sl@0: */
sl@0: void SelectRecordTest()
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	TInt err = TheDb.Create(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER, Name TEXT)"));
sl@0: 	TEST(err >= 0);
sl@0: 	err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
sl@0: 	TEST2(err, 1);
sl@0: 	TheDb.Close();
sl@0: 	err = -1;
sl@0: 	for(TInt cnt=0;err<KErrNone;++cnt)
sl@0: 		{		
sl@0: 		TheTest.Printf(_L("%d \r"), cnt);		
sl@0: 		err = TheDb.Open(KTestDbName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		RSqlStatement stmt;
sl@0: 		(void)TheFs.SetErrorCondition(KErrGeneral, cnt);
sl@0: 		err = stmt.Prepare(TheDb, _L("SELECT * FROM A WHERE Id=?"));
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = stmt.BindInt(0, 1);
sl@0: 			if(err == KErrNone)
sl@0: 				{
sl@0: 				err = stmt.Next();
sl@0: 				TEST(err == KSqlAtRow || err < 0);
sl@0: 				if(err == KSqlAtRow)
sl@0: 					{
sl@0: 					TInt id = stmt.ColumnInt(0);
sl@0: 					TEST2(id, 1);
sl@0: 					TPtrC name;
sl@0: 					err = stmt.ColumnText(1, name);
sl@0: 					TEST2(err, KErrNone);
sl@0: 					TEST(name == _L("Name"));
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 		stmt.Close();
sl@0: 		TheDb.Close();
sl@0: 		//check the database content is the same as before the operation
sl@0: 		TEST(CheckRecord(KTestDbName, 1, _L("Name")));
sl@0: 		}
sl@0: 	(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 	TEST(err >= 0);
sl@0: 	TheDb.Close();
sl@0: 	//check the database content is the same as before the operation, after reopening the database.
sl@0: 	TEST(CheckRecord(KTestDbName, 1, _L("Name")));
sl@0: 	err = RSqlDatabase::Delete(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheTest.Printf(_L("\r\n"));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-3463
sl@0: @SYMTestCaseDesc		Test for DEF105434 "SQL, persistent file I/O simulation, COMMIT problem".
sl@0: 						The test creates a test database with one table, inserts one record.
sl@0: 						Then the test attempts to insert another while simulating file I/O failures.
sl@0: 						After each iteration, the database content is tested, that it has not been modified by the operation.
sl@0: 						If the operation succeeds, the database content is tested again to check that the inserted record is there.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Test for DEF105434 "SQL, persistent file I/O simulation, COMMIT problem".
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMDEF					DEF105434
sl@0: */
sl@0: void InsertRecordTest()
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	TInt err = TheDb.Create(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Name TEXT)"));
sl@0: 	TEST(err >= 0);
sl@0: 	err = TheDb.Exec(_L("INSERT INTO A(Id,Name) VALUES(1,'Name')"));
sl@0: 	TEST2(err, 1);
sl@0: 	TheDb.Close();
sl@0: 	err = -1;
sl@0: 	for(TInt cnt=0;err<KErrNone;++cnt)
sl@0: 		{		
sl@0: 		TheTest.Printf(_L("%d \r"), cnt);		
sl@0: 		err = TheDb.Open(KTestDbName);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		RSqlStatement stmt;
sl@0: 		(void)TheFs.SetErrorCondition(KErrGeneral, cnt);
sl@0: 		err = stmt.Prepare(TheDb, _L("INSERT INTO A(Id,Name) VALUES(2, 'Name2')"));
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			err = TheDb.Exec(_L("BEGIN TRANSACTION"));
sl@0: 			if(err == KErrNone)
sl@0: 				{
sl@0: 				err = stmt.Exec();
sl@0: 				TEST(err == 1 || err < 0);
sl@0: 				if(err == 1)
sl@0: 					{
sl@0: 					err = TheDb.Exec(_L("COMMIT TRANSACTION"));
sl@0: 					}
sl@0: 				}
sl@0: 			}
sl@0: 		(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 		stmt.Close();
sl@0: 		if(err < 1)
sl@0: 			{
sl@0: 			TheDb.Close();//close the database to recover from the last error
sl@0: 			//check that the database contains the "name" record that has been inserted before the file I/O failure test.
sl@0: 			TEST(CheckRecord(KTestDbName, 1, _L("Name")));
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			TEST2(err, 1);
sl@0: 			//check the database content has been modified by the operation, without closing the database.
sl@0: 			TEST(CheckRecord(KTestDbName, 1, _L("Name"), EFalse));
sl@0: 			TEST(CheckRecord(KTestDbName, 2, _L("Name2"), EFalse));
sl@0: 			TheDb.Close();
sl@0: 			}
sl@0: 		}
sl@0: 	(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 	TEST2(err, 1);
sl@0: 	//check the database content (transaction durability).
sl@0: 	TEST(CheckRecord(KTestDbName, 1, _L("Name")));
sl@0: 	TEST(CheckRecord(KTestDbName, 2, _L("Name2")));
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	TheTest.Printf(_L("\r\n"));
sl@0: 	}
sl@0: 
sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: //////////////////////////////////         Removable media robustness test      /////////////////////////////////////////
sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: _LIT8(KNameColData, "A123456789012345678901234567890");
sl@0: _LIT8(KUpdatedNameColData, "1234");
sl@0: 
sl@0: //TRemovableMediaTest class is used for testing the SQLITE behaviour when the database file is created on a removable media where
sl@0: //the cluster size is bigger than the page size and in case of a power failure is not guaranteed that the content
sl@0: //of the last updated cluster will be preserved.
sl@0: class TRemovableMediaTest
sl@0: 	{
sl@0: 	enum {KTestRecCnt = 200};
sl@0: 	enum {KMinCachePageSize = 512};
sl@0: 	
sl@0: public:	
sl@0: 	void Run();
sl@0: 	
sl@0: private:	
sl@0: 	TInt GetRemovableMediaDriveNo();
sl@0: 	TInt ClusterSize(TInt aDriveNo);
sl@0: 	void CreateDatabase(TInt aDriveNo, TInt aCachePageSize);
sl@0: 	void CheckRecord(sqlite3_stmt* aStmt, TInt aRecId);
sl@0: 	void VerifyDatabase();
sl@0: 	void DoTest();
sl@0: 
sl@0: 	};
sl@0: 
sl@0: //Returns the number of the removable media drive, KErrNotFound otherwise.
sl@0: TInt TRemovableMediaTest::GetRemovableMediaDriveNo()
sl@0: 	{
sl@0: 	for(TInt driveNo=EDriveA;driveNo<=EDriveZ;++driveNo)
sl@0: 		{
sl@0: 		TDriveInfo driveInfo;
sl@0: 		TInt err = TheFs.Drive(driveInfo, driveNo);
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			_LIT(KType1, "Not present");
sl@0: 			_LIT(KType2, "Unknown");
sl@0: 			_LIT(KType3, "Floppy");
sl@0: 			_LIT(KType4, "Hard disk");
sl@0: 			_LIT(KType5, "CD ROM");
sl@0: 			_LIT(KType6, "RAM disk");
sl@0: 			_LIT(KType7, "Flash");
sl@0: 			_LIT(KType8, "ROM drive");
sl@0: 			_LIT(KType9, "Remote drive");
sl@0: 			_LIT(KType10,"NAND flash");
sl@0: 			_LIT(KType11,"Rotating media");
sl@0: 			_LIT(KYes, "Yes");
sl@0: 			_LIT(KNo,  "No ");
sl@0: 			TPtrC KMediaTypeNames[] = {KType1(), KType2(), KType3(), KType4(), KType5(), KType6(), KType7(), KType8(), KType9(), KType10(), KType11()};
sl@0: 			TheTest.Printf(_L("Drive: %C:, %S, Removable: %S\r\n"), 'A' + driveNo, &KMediaTypeNames[driveInfo.iType], 
sl@0: 																	driveInfo.iDriveAtt & KDriveAttRemovable ? &KYes : &KNo);
sl@0: 			if(driveInfo.iDriveAtt & KDriveAttRemovable)
sl@0: 				{
sl@0: 				TheTest.Printf(_L("Removable drive to test: %C:\r\n"), 'A' + driveNo);
sl@0: 				return driveNo;	
sl@0: 				}
sl@0: 			}
sl@0: 		}
sl@0: 	return KErrNotFound;
sl@0: 	}
sl@0: 
sl@0: //Get the cluster size of aDriveNo drive	
sl@0: TInt TRemovableMediaTest::ClusterSize(TInt aDriveNo)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG((TUint)aDriveNo <= EDriveZ, User::Invariant());
sl@0: 	TVolumeIOParamInfo volIoParams;
sl@0: 	TInt err = TheFs.VolumeIOParam(aDriveNo, volIoParams);
sl@0: 	return (err == KErrNone) ? volIoParams.iClusterSize : err;
sl@0: 	}
sl@0: 
sl@0: //Create a test database on aDriveNo with aCachePageSize page size.
sl@0: //Insert KTestRecCnt records.
sl@0: void TRemovableMediaTest::CreateDatabase(TInt aDriveNo, TInt aCachePageSize)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG((TUint)aDriveNo <= EDriveZ, User::Invariant());
sl@0: 	__ASSERT_DEBUG(aCachePageSize > 0, User::Invariant());
sl@0: 	TDriveUnit drvUnit(aDriveNo);
sl@0: 	_LIT(KDbName, "\\flashmedia.db");
sl@0: 	TParse parse;
sl@0: 	parse.Set(drvUnit.Name(), &KDbName, 0);
sl@0: 	TheRmvMediaDbFileName.Copy(parse.FullName());
sl@0: 	TBuf8<KMaxFileName + 1> dbFileName8;
sl@0: 	dbFileName8.Copy(TheRmvMediaDbFileName);
sl@0: 	(void)TheFs.Delete(TheRmvMediaDbFileName);
sl@0: 	
sl@0: 	sqlite3* dbHandle = NULL;
sl@0: 	TInt rc = sqlite3_open((const char*)dbFileName8.PtrZ(), &dbHandle);
sl@0: 	SQLITE_TEST(dbHandle, rc, SQLITE_OK);
sl@0: 	__ASSERT_DEBUG(dbHandle != NULL, User::Invariant());
sl@0: 	
sl@0: 	TBuf8<40> config;
sl@0: 	config.Copy(_L8("PRAGMA PAGE_SIZE="));
sl@0: 	config.AppendNum(aCachePageSize);
sl@0: 	rc = sqlite3_exec(dbHandle, (const char*)config.PtrZ(), 0, 0, 0);
sl@0: 	SQLITE_TEST(dbHandle, rc, SQLITE_OK);
sl@0: 
sl@0: 	rc = sqlite3_exec(dbHandle, "CREATE TABLE A(Id INTEGER,Name TEXT)", 0, 0, 0);
sl@0: 	SQLITE_TEST(dbHandle, rc, SQLITE_OK);
sl@0: 	rc = sqlite3_exec(dbHandle, "BEGIN", 0, 0, 0);
sl@0: 	SQLITE_TEST(dbHandle, rc, SQLITE_OK);
sl@0: 	for(TInt recid=1;recid<=KTestRecCnt;++recid)
sl@0: 		{
sl@0: 		
sl@0: 		TBuf8<100> sql;
sl@0: 		sql.Copy(_L8("INSERT INTO A VALUES("));
sl@0: 		sql.AppendNum(recid);
sl@0: 		sql.Append(_L8(",'"));
sl@0: 		sql.Append(KNameColData);
sl@0: 		sql.Append(_L8("')"));
sl@0: 		rc = sqlite3_exec(dbHandle, (const char*)sql.PtrZ(), 0, 0, 0);
sl@0: 		SQLITE_TEST(dbHandle, rc, SQLITE_OK);
sl@0: 		}
sl@0: 	rc = sqlite3_exec(dbHandle, "COMMIT", 0, 0, 0);
sl@0: 	SQLITE_TEST(dbHandle, rc, SQLITE_OK);
sl@0: 	sqlite3_close(dbHandle);
sl@0: 	}
sl@0: 
sl@0: //Checks the content of a single record
sl@0: void TRemovableMediaTest::CheckRecord(sqlite3_stmt* aStmt, TInt aRecId)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aStmt != NULL, User::Invariant());
sl@0: 	TInt id = sqlite3_column_int(aStmt, 0);
sl@0: 	TEST2(id, aRecId);
sl@0: 	const TUint8* text = (const TUint8*)sqlite3_column_text(aStmt, 1);
sl@0: 	TPtrC8 name(text, User::StringLength(text));
sl@0: 	TEST(KNameColData() == name || KUpdatedNameColData() == name);
sl@0: 	}
sl@0: 
sl@0: //Verifies that the database content is either the same as it was before the UPDATE operation or 
sl@0: //it has been updated with the new data.
sl@0: void TRemovableMediaTest::VerifyDatabase()
sl@0: 	{
sl@0: 	TBuf8<KMaxFileName + 1> dbFileName8;
sl@0: 	dbFileName8.Copy(TheRmvMediaDbFileName);
sl@0: 	
sl@0: 	sqlite3* dbHandle = NULL;
sl@0: 	TInt rc = sqlite3_open((const char*)dbFileName8.PtrZ(), &dbHandle);
sl@0: 	SQLITE_TEST(dbHandle, rc, SQLITE_OK);
sl@0: 	__ASSERT_DEBUG(dbHandle != NULL, User::Invariant());
sl@0: 	
sl@0: 	sqlite3_stmt* stmtHandle = NULL;
sl@0: 	rc = sqlite3_prepare(dbHandle, "SELECT Id,Name FROM A", -1, &stmtHandle, 0);
sl@0: 	SQLITE_TEST(dbHandle, rc, SQLITE_OK);
sl@0: 	__ASSERT_DEBUG(stmtHandle != NULL, User::Invariant());
sl@0: 	
sl@0: 	for(TInt recid=1;recid<=KTestRecCnt;++recid)
sl@0: 		{
sl@0: 		rc = sqlite3_step(stmtHandle);
sl@0: 		SQLITE_TEST(dbHandle, rc, SQLITE_ROW);
sl@0: 		CheckRecord(stmtHandle, recid);
sl@0: 		}
sl@0: 	rc = sqlite3_step(stmtHandle);
sl@0: 	SQLITE_TEST(dbHandle, rc, SQLITE_DONE);
sl@0: 	
sl@0: 	sqlite3_finalize(stmtHandle);
sl@0: 	sqlite3_close(dbHandle);
sl@0: 	}
sl@0: 
sl@0: //Simulates a file system error in a loop.
sl@0: //Attempts to update single record in a transaction.
sl@0: //If the UPDATE operation fails - verifies the database content on each iteration.
sl@0: //Note: pages are stored at the moment, not clusters. The database operations are not more robust if
sl@0: //      clusters are stored in a case of a removable media.
sl@0: void TRemovableMediaTest::DoTest()
sl@0: 	{
sl@0: 	TheTest.Printf(_L("Update 1 record in a file I/o simulation loop\r\n"));		
sl@0: 	TInt rc = -1;
sl@0: 	TBuf8<KMaxFileName + 1> dbFileName8;
sl@0: 	dbFileName8.Copy(TheRmvMediaDbFileName);
sl@0: 	for(TInt cnt=0;rc!=SQLITE_OK;++cnt)
sl@0: 		{		
sl@0: 		TheTest.Printf(_L("%d \r"), cnt);		
sl@0: 		sqlite3* dbHandle = NULL;
sl@0: 		rc = sqlite3_open((const char*)dbFileName8.PtrZ(), &dbHandle);
sl@0: 		SQLITE_TEST(dbHandle, rc, SQLITE_OK);
sl@0: 		__ASSERT_DEBUG(dbHandle != NULL, User::Invariant());
sl@0: 		(void)TheFs.SetErrorCondition(KErrCorrupt, cnt);
sl@0: 		rc = sqlite3_exec(dbHandle, "BEGIN IMMEDIATE", 0, 0, 0);
sl@0: 		if(rc == SQLITE_OK)
sl@0: 			{
sl@0: 			rc = sqlite3_exec(dbHandle, "UPDATE A SET Name='1234' WHERE Id=1", 0, 0, 0);
sl@0: 			if(rc == SQLITE_OK)
sl@0: 				{
sl@0: 				TInt cnt = sqlite3_changes(dbHandle);
sl@0: 				TEST2(cnt, 1);
sl@0: 				rc = sqlite3_exec(dbHandle, "COMMIT", 0, 0, 0);
sl@0: 				}
sl@0: 			}
sl@0: 		(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 		sqlite3_close(dbHandle);
sl@0: 		if(rc != SQLITE_OK)
sl@0: 			{
sl@0: 			VerifyDatabase();
sl@0: 			}
sl@0: 		}
sl@0: 	TEST2(rc, SQLITE_OK);
sl@0: 	VerifyDatabase();
sl@0: 	}
sl@0: 	
sl@0: void TRemovableMediaTest::Run()
sl@0: 	{
sl@0: 	TInt driveNo = GetRemovableMediaDriveNo();
sl@0: 	if(driveNo == KErrNotFound)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("No removable media discovered. Test case not executed.\r\n"));	
sl@0: 		return;
sl@0: 		}
sl@0: 	TInt clusterSize = ClusterSize(driveNo);
sl@0: 	if(clusterSize < 0)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("Error %d retrieving the cluster size of drive %C. Test case not executed.\r\n"), clusterSize, 'A' + driveNo);
sl@0: 		return;
sl@0: 		}
sl@0: 	if(clusterSize <= KMinCachePageSize)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("Cluster size: %d. No appropriate cache page size found. Test case not executed.\r\n"), clusterSize);	
sl@0: 		return;
sl@0: 		}
sl@0: 		
sl@0: 	TheTest.Printf(_L("Cluster size: %d. Cache page size %d.\r\nBegin test.\r\n"), clusterSize, KMinCachePageSize);	
sl@0: 	CreateDatabase(driveNo, KMinCachePageSize);
sl@0: 	DoTest();
sl@0: 	(void)TheFs.Delete(TheRmvMediaDbFileName);
sl@0: 	TheTest.Printf(_L("End test.\r\n"));
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-3516
sl@0: @SYMTestCaseDesc		Removable media robustness test
sl@0: 						The test creates a test database with a table with some records. Then the test verifies
sl@0: 						that the database content cannot be corrupted by file I/O failures during database updates, 
sl@0: 						when the database file is on a removable media and the media cluster size is bigger than the 
sl@0: 						database page size.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			Removable media robustness test
sl@0: @SYMTestExpectedResults The test must not fail
sl@0: @SYMREQ					REQ7913
sl@0: */
sl@0: void RemovableMediaRobustnessTest()
sl@0: 	{
sl@0: 	TRemovableMediaTest removableMediaTest;
sl@0: 	removableMediaTest.Run();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4044
sl@0: @SYMTestCaseDesc		RSqlDatabase::Size(TSize&), file I/O error simulation test.
sl@0: 						The test creates a database and executes RSqldatabase::Size(TSize&)
sl@0: 						during a file I/O error simulation. The database should not be corrupted 
sl@0: 						by the call.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlDatabase::Size(TSize&), file I/O error simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10407
sl@0: */
sl@0: void SizeTest()
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	TInt err = TheDb.Create(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("BEGIN;CREATE TABLE A(Id INTEGER,Data BLOB);INSERT INTO A VALUES(1, x'11223344');COMMIT;"));
sl@0: 	TEST(err >= 0);
sl@0: 	RSqlDatabase::TSize size1 = {-1, -1};
sl@0: 	err = TheDb.Size(size1);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST(size1.iSize > 0);
sl@0: 	TEST2(size1.iFree, 0);
sl@0: 	TheDb.Close();
sl@0: 	//"File I/O" error simulation loop
sl@0: 	err = KErrCorrupt;
sl@0: 	for(TInt cnt=0;err<KErrNone;++cnt)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("%d \r"), cnt);		
sl@0: 		TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 		(void)TheFs.SetErrorCondition(KErrCorrupt, cnt);
sl@0: 		RSqlDatabase::TSize size2 = {-1, -1};
sl@0: 		err = TheDb.Size(size2);
sl@0: 		(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 		TheDb.Close();
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			TEST(size2.iSize == size1.iSize);
sl@0: 			TEST(size2.iFree == size1.iFree);
sl@0: 			break;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			//check the database content - all bets are off in a case of an I/O error. 
sl@0: 			TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 			TSqlScalarFullSelectQuery q(TheDb);
sl@0: 			TInt recCnt = 0;
sl@0: 			TRAPD(err2, recCnt = q.SelectIntL(_L8("SELECT COUNT(*) FROM A")));
sl@0: 			TheDb.Close();
sl@0: 			TEST2(err2, KErrNone);
sl@0: 			TEST2(recCnt, 1);
sl@0: 			}
sl@0: 		}
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4045
sl@0: @SYMTestCaseDesc		RSqlDatabase::Compact(), file I/O error simulation test.
sl@0: 						The test creates a database and executes RSqlDatabase::Compact()
sl@0: 						during a file I/O error simulation. The database should not be corrupted 
sl@0: 						by the call.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlDatabase::Compact(), file I/O error simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ10405
sl@0: */
sl@0: void CompactTest()
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	_LIT8(KConfig, "compaction=manual");
sl@0: 	TInt err = TheDb.Create(KTestDbName, &KConfig);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Data BLOB)"));
sl@0: 	TEST(err >= 0);
sl@0: 	//Insert records
sl@0: 	err = TheDb.Exec(_L8("BEGIN"));
sl@0: 	TEST(err >= 0);
sl@0: 	const TInt KRecLen = 1000;
sl@0: 	TBuf8<KRecLen> sqlfmt;
sl@0: 	sqlfmt.Copy(_L8("INSERT INTO A VALUES(%d,x'"));
sl@0: 	for(TInt j=0;j<(KRecLen-50);++j)
sl@0: 		{
sl@0: 		sqlfmt.Append(_L8("A"));
sl@0: 		}
sl@0: 	sqlfmt.Append(_L8("')"));
sl@0: 	const TInt KRecCount = 100;	
sl@0: 	for(TInt i=0;i<KRecCount;++i)
sl@0: 		{
sl@0: 		TBuf8<KRecLen> sql;
sl@0: 		sql.Format(sqlfmt, i + 1);
sl@0: 		err = TheDb.Exec(sql);
sl@0: 		TEST2(err, 1);
sl@0: 		}
sl@0: 	err = TheDb.Exec(_L8("COMMIT"));
sl@0: 	TEST(err >= 0);
sl@0: 	//Free some space
sl@0: 	const TInt KDeletedRecCnt = KRecCount - 10;
sl@0: 	err = TheDb.Exec(_L8("DELETE FROM A WHERE Id > 10"));
sl@0: 	TEST(err >= 0);
sl@0: 	//Get the database size
sl@0: 	RSqlDatabase::TSize size;
sl@0: 	err = TheDb.Size(size);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	TEST(size.iSize > 0);
sl@0: 	TEST(size.iFree > 0);
sl@0: 	//"File I/O" error simulation loop
sl@0: 	err = KErrCorrupt;
sl@0: 	for(TInt cnt=0;err<KErrNone;++cnt)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("%d \r"), cnt);		
sl@0: 		TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 		(void)TheFs.SetErrorCondition(KErrCorrupt, cnt);
sl@0: 		err = TheDb.Compact(RSqlDatabase::EMaxCompaction);
sl@0: 		(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 		TheDb.Close();
sl@0: 		if(err == KErrNone)
sl@0: 			{
sl@0: 			break;
sl@0: 			}
sl@0: 		else
sl@0: 			{
sl@0: 			//check the database content - all bets are off in a case of an I/O error. 
sl@0: 			//The database maight have been compacted, so - no check for that.
sl@0: 			TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 			TSqlScalarFullSelectQuery q(TheDb);
sl@0: 			TInt recCnt = 0;
sl@0: 			TRAPD(err2, recCnt = q.SelectIntL(_L8("SELECT COUNT(*) FROM A")));
sl@0: 			TheDb.Close();
sl@0: 			TEST2(err2, KErrNone);
sl@0: 			TEST2(recCnt, (KRecCount - KDeletedRecCnt));
sl@0: 			}
sl@0: 		}
sl@0: 	TheTest.Printf(_L("\r\n"));
sl@0: 	//Check that the database has been really compacted
sl@0: 	TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 	RSqlDatabase::TSize size2;
sl@0: 	err = TheDb.Size(size2);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	TEST(size.iSize > size2.iSize);
sl@0: 	TEST2(size2.iFree, 0);
sl@0: 	}
sl@0: 
sl@0: void DoBlobWriteStreamTestL(TBool aAttachDb)
sl@0: 	{
sl@0: 	RSqlBlobWriteStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	if(aAttachDb)
sl@0: 		{
sl@0: 		strm.OpenL(TheDb, _L("A"), _L("Data"), 1, KAttachDb);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		strm.OpenL(TheDb, _L("A"), _L("Data"), 1);
sl@0: 		}
sl@0: 
sl@0: 	TBuf8<KBlobSize / KWriteCnt> data;
sl@0: 	data.SetLength(KBlobSize / KWriteCnt);
sl@0: 	data.Fill(0xA5);
sl@0: 	
sl@0: 	for(TInt i=0;i<KWriteCnt;++i)
sl@0: 		{
sl@0: 		strm.WriteL(data);
sl@0: 		}
sl@0: 	
sl@0: 	strm.CommitL();
sl@0: 	
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4089
sl@0: @SYMTestCaseDesc		RSqlBlobWriteStream::WriteL(), file I/O error simulation test.
sl@0: 						The test creates a database and executes RSqlBlobWriteStream::WriteL()
sl@0: 						during a file I/O error simulation. The database should not be corrupted 
sl@0: 						by the call.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlBlobWriteStream::WriteL(), file I/O error simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ10418
sl@0: */
sl@0: void BlobWriteStreamTest(TBool aAttachDb)
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	TInt err = TheDb.Create(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Data BLOB)"));
sl@0: 	TEST2(err, 1);
sl@0: 	TBuf8<100> sql;
sl@0: 	sql.Format(_L8("INSERT INTO A VALUES(1, zeroblob(%d))"), KBlobSize);
sl@0: 	err = TheDb.Exec(sql);
sl@0: 	TEST2(err, 1);
sl@0: 	TheDb.Close();
sl@0: 	
sl@0: 	err = KErrCorrupt;
sl@0: 	for(TInt cnt=0;err<KErrNone;++cnt)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("%d \r"), cnt);		
sl@0: 		TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 		if(aAttachDb)
sl@0: 			{
sl@0: 			TEST2(TheDb.Attach(KTestDbName, KAttachDb), KErrNone);	
sl@0: 			}
sl@0: 		(void)TheFs.SetErrorCondition(KErrCorrupt, cnt);
sl@0: 		TRAP(err, DoBlobWriteStreamTestL(aAttachDb));
sl@0: 		(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 		if(aAttachDb)
sl@0: 			{
sl@0: 			TEST2(TheDb.Detach(KAttachDb), KErrNone);	
sl@0: 			}
sl@0: 		TheDb.Close();
sl@0: 		}
sl@0: 	TheTest.Printf(_L("\r\n"));
sl@0: 
sl@0: 	TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 	
sl@0: 	RSqlStatement stmt;
sl@0: 	err = stmt.Prepare(TheDb, _L8("SELECT * FROM A"));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = stmt.Next();
sl@0: 	TEST2(err, KSqlAtRow);
sl@0: 	TPtrC8 data;
sl@0: 	err = stmt.ColumnBinary(1, data);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TEST2(data.Length(), KBlobSize);
sl@0: 	for(TInt j=0;j<KBlobSize;++j)
sl@0: 		{
sl@0: 		TUint8 d = data[j];
sl@0: 		TEST2(d, 0xA5);	
sl@0: 		}
sl@0: 	stmt.Close();
sl@0: 	
sl@0: 	TheDb.Close();
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	}
sl@0: 
sl@0: void DoBlobReadStreamTestL(TBool aAttachDb, TDes8& aDes)
sl@0: 	{
sl@0: 	RSqlBlobReadStream strm;
sl@0: 	CleanupClosePushL(strm);
sl@0: 	if(aAttachDb)
sl@0: 		{
sl@0: 		strm.OpenL(TheDb, _L("A"), _L("Data"), 1, KAttachDb);
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		strm.OpenL(TheDb, _L("A"), _L("Data"), 1);
sl@0: 		}
sl@0: 
sl@0: 	TBuf8<KBlobSize / KWriteCnt> data;
sl@0: 	aDes.SetLength(0);
sl@0: 	
sl@0: 	for(TInt i=0;i<KWriteCnt;++i)
sl@0: 		{
sl@0: 		strm.ReadL(data);
sl@0: 		aDes.Append(data);
sl@0: 		}
sl@0: 	
sl@0: 	CleanupStack::PopAndDestroy(&strm);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID			SYSLIB-SQL-UT-4090
sl@0: @SYMTestCaseDesc		RSqlBlobReadStream::ReadL(), file I/O error simulation test.
sl@0: 						The test creates a database and executes RSqlBlobReadStream::ReadL()
sl@0: 						during a file I/O error simulation. The database should not be corrupted 
sl@0: 						by the call.
sl@0: @SYMTestPriority		High
sl@0: @SYMTestActions			RSqlBlobReadStream::ReadL(), file I/O error simulation test.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMREQ					REQ5792
sl@0:                         REQ10410
sl@0:                         REQ10411
sl@0: */
sl@0: void BlobReadStreamTest(TBool aAttachDb)
sl@0: 	{
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	TInt err = TheDb.Create(KTestDbName);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	err = TheDb.Exec(_L("CREATE TABLE A(Id INTEGER,Data BLOB)"));
sl@0: 	TEST2(err, 1);
sl@0: 	TBuf8<100> sql;
sl@0: 	sql.Format(_L8("INSERT INTO A VALUES(1, zeroblob(%d))"), KBlobSize);
sl@0: 	err = TheDb.Exec(sql);
sl@0: 	TEST2(err, 1);
sl@0: 	TRAP(err, DoBlobWriteStreamTestL(EFalse));
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TheDb.Close();
sl@0: 	
sl@0: 	HBufC8* buf = HBufC8::New(KBlobSize);
sl@0: 	TEST(buf != NULL);
sl@0: 	TPtr8 bufptr = buf->Des();
sl@0: 	
sl@0: 	err = KErrCorrupt;
sl@0: 	for(TInt cnt=0;err<KErrNone;++cnt)
sl@0: 		{
sl@0: 		TheTest.Printf(_L("%d \r"), cnt);		
sl@0: 		TEST2(TheDb.Open(KTestDbName), KErrNone);
sl@0: 		if(aAttachDb)
sl@0: 			{
sl@0: 			TEST2(TheDb.Attach(KTestDbName, KAttachDb), KErrNone);	
sl@0: 			}
sl@0: 		(void)TheFs.SetErrorCondition(KErrCorrupt, cnt);
sl@0: 		TRAP(err, DoBlobReadStreamTestL(aAttachDb, bufptr));
sl@0: 		(void)TheFs.SetErrorCondition(KErrNone);
sl@0: 		if(aAttachDb)
sl@0: 			{
sl@0: 			TEST2(TheDb.Detach(KAttachDb), KErrNone);	
sl@0: 			}
sl@0: 		TheDb.Close();
sl@0: 		}
sl@0: 	TheTest.Printf(_L("\r\n"));
sl@0: 
sl@0: 	TEST2(bufptr.Length(), KBlobSize);
sl@0: 	for(TInt j=0;j<KBlobSize;++j)
sl@0: 		{
sl@0: 		TUint8 d = bufptr[j];
sl@0: 		TEST2(d, 0xA5);	
sl@0: 		}
sl@0: 		
sl@0: 	delete buf;
sl@0: 		
sl@0: 	(void)RSqlDatabase::Delete(KTestDbName);
sl@0: 	}
sl@0: 
sl@0: /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: void DoTests()
sl@0: 	{
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3419 Alter database during file I/O error "));
sl@0: 	AlterDatabaseTest();
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3420 Alter database during file I/O error (using statement object) "));
sl@0: 	AlterDatabaseTest2();
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3421 Open database during file I/O error "));
sl@0: 	OpenDatabaseTest();
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3434 Create database during file I/O error "));
sl@0: 	CreateDatabaseTest();
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4189 Attach database during file I/O error "));
sl@0:     AttachDatabaseTest();
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-UT-4190 Delete database during file I/O error "));
sl@0:     DeleteDatabaseTest();
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3462 Select record test during file I/O error "));
sl@0: 	SelectRecordTest();
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3463 Insert record test during file I/O error "));
sl@0: 	InsertRecordTest();
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-3516 Removable Media robustness test "));
sl@0: 	RemovableMediaRobustnessTest();
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4044 Database size test during file I/O error"));	
sl@0: 	SizeTest();
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4045 Compact database test during file I/O error"));	
sl@0: 	CompactTest();
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4089 RSqlBlobWriteStream::WriteL() test during file I/O error"));	
sl@0: 	BlobWriteStreamTest(EFalse);
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4089 RSqlBlobWriteStream::WriteL()+attached database test during file I/O error"));	
sl@0: 	BlobWriteStreamTest(ETrue);
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4090 RSqlBlobReadStream::ReadL() test during file I/O error"));	
sl@0: 	BlobReadStreamTest(EFalse);
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-UT-4090 RSqlBlobReadStream::ReadL()+attached database test during file I/O error"));	
sl@0: 	BlobReadStreamTest(ETrue);
sl@0: 	}
sl@0: 
sl@0: TInt E32Main()
sl@0: 	{
sl@0: 	TheTest.Title();
sl@0: 	
sl@0: 	CTrapCleanup* tc = CTrapCleanup::New();
sl@0: 	
sl@0: 	__UHEAP_MARK;
sl@0: 	
sl@0: 	SetupTestEnv();
sl@0: 	DoTests();
sl@0: 	DestroyTestEnv();
sl@0: 	
sl@0: 	__UHEAP_MARKEND;
sl@0: 	
sl@0: 	TheTest.End();
sl@0: 	TheTest.Close();
sl@0: 	
sl@0: 	delete tc;
sl@0: 	
sl@0: 	User::Heap().Check();
sl@0: 	return KErrNone;
sl@0: 	}