sl@0: // Copyright (c) 2006-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 <f32file.h>
sl@0: #include <sqldb.h>
sl@0: #include <f32file.h>
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: static RFs TheFs;
sl@0: static RTest TheTest(_L("t_sqldefect2 test"));
sl@0: static RSqlDatabase TheDb1;
sl@0: static RSqlDatabase TheDb2;
sl@0: 
sl@0: _LIT(KTestDir, "c:\\test\\");
sl@0: _LIT(KTestDatabase1, "c:\\test\\t_sqldefect2.db");
sl@0: _LIT(KTestDatabaseJournal1, "c:\\test\\t_sqldefect2.db-journal");
sl@0: _LIT(KServerTempDir, "c:\\private\\10281e17\\temp\\");
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Deletes all created test files.
sl@0: void DestroyTestEnv()
sl@0: 	{
sl@0:     TheDb2.Close();
sl@0:     TheDb1.Close();
sl@0: 	(void)RSqlDatabase::Delete(KTestDatabase1);
sl@0: 	TheFs.Close();
sl@0: 	}
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: //Test macros and functions
sl@0: void Check1(TInt aValue, TInt aLine)
sl@0: 	{
sl@0: 	if(!aValue)
sl@0: 		{
sl@0: 		DestroyTestEnv();
sl@0: 		RDebug::Print(_L("*** Line %d\r\n"), aLine);
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: void Check2(TInt aValue, TInt aExpected, TInt aLine)
sl@0: 	{
sl@0: 	if(aValue != aExpected)
sl@0: 		{
sl@0: 		DestroyTestEnv();
sl@0: 		RDebug::Print(_L("*** Line %d, Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);
sl@0: 		TheTest(EFalse, aLine);
sl@0: 		}
sl@0: 	}
sl@0: #define TEST(arg) ::Check1((arg), __LINE__)
sl@0: #define TEST2(aValue, aExpected) ::Check2(aValue, aExpected, __LINE__)
sl@0: 
sl@0: ///////////////////////////////////////////////////////////////////////////////////////
sl@0: 
sl@0: //Creates file session instance and the test directory
sl@0: void CreateTestEnv()
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: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4154
sl@0: @SYMTestCaseDesc        Test for DEF143062: SQL, "CREATE INDEX" sql crashes SQL server.
sl@0:                         The test creates a database with one empty table and establishes two connections
sl@0:                         to that database. Then, while the first connection is at the middle of a read
sl@0:                         transaction, the second connection attempts to create an index.
sl@0:                         If the defect is not fixed, the SQL server will crash.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         DEF143062: SQL, "CREATE INDEX" sql crashes SQL server.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF143062
sl@0: */
sl@0: void DEF143062()
sl@0:     {
sl@0:     (void)RSqlDatabase::Delete(KTestDatabase1);
sl@0:     TInt err = TheDb1.Create(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = TheDb1.Exec(_L("CREATE TABLE T0(Thread INTEGER, LocalIndex INTEGER, Inserts INTEGER, Updates INTEGER, IndexMod8 INTEGER)"));
sl@0:     TEST(err >= 0);
sl@0:     
sl@0:     err = TheDb2.Open(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     RSqlStatement stmt;
sl@0:     err = stmt.Prepare(TheDb1, _L8("SELECT COUNT(Thread) FROM T0 WHERE Thread = 0"));
sl@0:     TEST2(err, KErrNone);
sl@0:     err = stmt.Next();
sl@0:     TEST2(err, KSqlAtRow);
sl@0:     
sl@0:     err = TheDb2.Exec(_L8("CREATE INDEX T0INDEX ON T0(Thread,IndexMod8)"));//crashes the SQL server if the defect is not fixed 
sl@0:     TEST2(err, KSqlErrLocked);
sl@0:     
sl@0:     stmt.Close();
sl@0:     
sl@0:     TheDb2.Close();
sl@0:     TheDb1.Close();
sl@0:     err = RSqlDatabase::Delete(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4155
sl@0: @SYMTestCaseDesc        Test for DEF143061: SQL, SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT value is too big.
sl@0:                                          The test verifies that after comitting a big transaction, the journal file size is made equal the 
sl@0:                                           max journal file size limit of 64Kb.
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         DEF143061: SQL, SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT value is too big..
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF143061
sl@0: */
sl@0: void DEF143061()
sl@0:     {
sl@0:     (void)RSqlDatabase::Delete(KTestDatabase1);
sl@0:     //"Auto" compaction is used in order to see how the journal file is immediatelly used.
sl@0:     _LIT8(KConfig, "compaction=auto");
sl@0:     TInt err = TheDb1.Create(KTestDatabase1, &KConfig);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = TheDb1.Exec(_L("CREATE TABLE A(I INTEGER, B BLOB)"));
sl@0:     TEST(err >= 0);
sl@0: 
sl@0:     const TInt KBlobSize = 100000;//bigger than the journal size limit
sl@0:     HBufC8* buf = HBufC8::New(KBlobSize);
sl@0:     TEST(buf != NULL);
sl@0:     TPtr8 ptr = buf->Des();
sl@0:     ptr.SetLength(KBlobSize);
sl@0:         
sl@0:     RSqlStatement stmt;
sl@0:     err = stmt.Prepare(TheDb1, _L("INSERT INTO A VALUES(1, :Prm)"));
sl@0:     TEST2(err, KErrNone);
sl@0:     ptr.Fill(TChar('N'));
sl@0:     err = stmt.BindBinary(0, ptr);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = stmt.Exec();
sl@0:     TEST2(err, 1);
sl@0:     stmt.Close();
sl@0:     
sl@0:     //Try to update the BLOB in the record that was just inserted. This operation should create a big journal file.
sl@0:     err = stmt.Prepare(TheDb1, _L("UPDATE A SET B=:Prm WHERE I=1"));
sl@0:     TEST2(err, KErrNone);
sl@0:     ptr.Fill(TChar('Y'));
sl@0:     err = stmt.BindBinary(0, ptr);
sl@0:     TEST2(err, KErrNone);
sl@0:     err = stmt.Exec();
sl@0:     TEST2(err, 1);
sl@0:     stmt.Close();
sl@0:     
sl@0:     //Check the journal file size. It should be less than the 64Kb limit defined in sqlite_macro.mmh file.  
sl@0:     TEntry entry;
sl@0:     err = TheFs.Entry(KTestDatabaseJournal1, entry);
sl@0:     TEST2(err, KErrNone);
sl@0:     TInt64 fsize = entry.FileSize();
sl@0:     TEST(fsize <= SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT);
sl@0:     
sl@0:     delete buf;
sl@0:     TheDb1.Close();
sl@0:     err = RSqlDatabase::Delete(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4156
sl@0: @SYMTestCaseDesc        Test for DEF143150: SQL, strftime() returns incorrect result.
sl@0:                         The test takes the current universal time (using TTime) 
sl@0:                         and the current time retrieved from the SQL  server.
sl@0:                         The test compares the times and expects the difference to be no more than
sl@0:                         1 second. 
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         DEF143150: SQL, strftime() returns incorrect result
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: @SYMDEF                 DEF143150
sl@0: */
sl@0: void DEF143150()
sl@0:     {
sl@0:     (void)RSqlDatabase::Delete(KTestDatabase1);
sl@0:     TInt err = TheDb1.Create(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0: 
sl@0:     //Home date & time
sl@0:     TBuf<50> dtstr1;
sl@0:     TTime time;
sl@0:     time.UniversalTime();
sl@0:     TDateTime dt = time.DateTime();
sl@0:     
sl@0:     RSqlStatement stmt;
sl@0:     err = stmt.Prepare(TheDb1, _L("SELECT strftime('%Y-%m-%d,%H:%M:%S','now')"));
sl@0:     TEST2(err, KErrNone);
sl@0:     err = stmt.Next();
sl@0:     TEST2(err, KSqlAtRow);
sl@0:     
sl@0:     //SQLite date & time
sl@0:     TBuf<50> dtstr2;
sl@0:     err = stmt.ColumnText(0, dtstr2);
sl@0:     TEST2(err, KErrNone);
sl@0:     stmt.Close();
sl@0: 
sl@0:     TheDb1.Close();
sl@0:     err = RSqlDatabase::Delete(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     dtstr1.Format(_L("%04d-%02d-%02d,%02d:%02d:%02d"), dt.Year(), dt.Month() + 1, dt.Day() + 1, dt.Hour(), dt.Minute(), dt.Second());
sl@0:     TheTest.Printf(_L("Universal date&time=\"%S\"\n"), &dtstr1);
sl@0:     TheTest.Printf(_L("SQLite    date&time=\"%S\"\n"), &dtstr2);
sl@0:     
sl@0:     //Comapare and fail if dates are not equal (+- 1 second)
sl@0:     TLex lex;
sl@0:     lex = dtstr2.Mid(0, 4);
sl@0:     TInt sqlyear;
sl@0:     err = lex.Val(sqlyear);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     lex = dtstr2.Mid(5, 2);
sl@0:     TInt sqlmonth;
sl@0:     err = lex.Val(sqlmonth);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     lex = dtstr2.Mid(8, 2);
sl@0:     TInt sqlday;
sl@0:     err = lex.Val(sqlday);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     lex = dtstr2.Mid(11, 2);
sl@0:     TInt sqlhour;
sl@0:     err = lex.Val(sqlhour);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     lex = dtstr2.Mid(14, 2);
sl@0:     TInt sqlminute;
sl@0:     err = lex.Val(sqlminute);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     lex = dtstr2.Mid(17, 2);
sl@0:     TInt sqlsecond;
sl@0:     err = lex.Val(sqlsecond);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     TDateTime sqldt(sqlyear, (TMonth)(sqlmonth - 1), sqlday - 1, sqlhour, sqlminute, sqlsecond, 0);
sl@0:     TTime sqltime(sqldt);
sl@0:     TTimeIntervalSeconds diff;
sl@0:     err = sqltime.SecondsFrom(time, diff);
sl@0:     TEST2(err, KErrNone);
sl@0:     TEST(diff.Int() <= 1);
sl@0:     }
sl@0: 
sl@0: static TInt KillProcess(const TDesC& aProcessName)
sl@0:     {
sl@0:     TFullName name;
sl@0:     TBuf<64> pattern(aProcessName);
sl@0:     TInt length = pattern.Length();
sl@0:     pattern += _L("*");
sl@0:     TFindProcess procFinder(pattern);
sl@0: 
sl@0:     while (procFinder.Next(name) == KErrNone)
sl@0:         {
sl@0:         if (name.Length() > length)
sl@0:             {//If found name is a string containing aProcessName string.
sl@0:             TChar c(name[length]);
sl@0:             if (c.IsAlphaDigit() ||
sl@0:                 c == TChar('_') ||
sl@0:                 c == TChar('-'))
sl@0:                 {
sl@0:                 // If the found name is other valid application name
sl@0:                 // starting with aProcessName string.
sl@0:                 continue;
sl@0:                 }
sl@0:             }
sl@0:         RProcess proc;
sl@0:         if (proc.Open(name) == KErrNone)
sl@0:             {
sl@0:             proc.Kill(0);
sl@0:             }
sl@0:         proc.Close();
sl@0:         }
sl@0:     return KErrNone;
sl@0:     }
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4210
sl@0: @SYMTestCaseDesc        Test for the change "Temp files created during sql operations are not deleted after rebooting the phone" 
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         Kill the sql server
sl@0:                         Create two temp files in sql server's private directory
sl@0:                         Start the sql server
sl@0:                         Test that the temp files do not exist.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: */
sl@0: void DeleteTempFile()
sl@0:     {   
sl@0:     _LIT(KSqlSrvName, "sqlsrv.exe");
sl@0:     _LIT(KTempFile1, "TMP00052.$$$");
sl@0:     _LIT(KTempFile2, "TMP00044.$$$");
sl@0:     
sl@0:     KillProcess(KSqlSrvName);
sl@0:  
sl@0:     //Create two temp file in c:\\private\\10281e17\\temp\\ folder
sl@0:     TInt err = TheFs.MkDir(KServerTempDir);
sl@0:     TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0:     RFile file;
sl@0:     TFileName filename1(KServerTempDir);
sl@0:     TFileName filename2(KServerTempDir);
sl@0:     filename1.Append(KTempFile1);
sl@0:     filename2.Append(KTempFile2);
sl@0:     err = file.Replace(TheFs, filename1, 0);
sl@0:     file.Close();
sl@0:     TEST2(err, KErrNone);
sl@0:     err = file.Replace(TheFs, filename2, 0);
sl@0:     file.Close();
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     //Create a database that should start sql server
sl@0:     err = TheDb1.Create(KTestDatabase1);
sl@0:     TEST(err == KErrNone || err == KErrAlreadyExists);
sl@0:     //Test that the temp files have been deleted during server's start-up
sl@0:     TUint dummy;
sl@0:     err = TheFs.Att(filename1, dummy);
sl@0:     TEST2(err, KErrNotFound);
sl@0:     err = TheFs.Att(filename2, dummy);
sl@0:     TEST2(err, KErrNotFound);
sl@0:     
sl@0:     TheDb1.Close();
sl@0:     err = RSqlDatabase::Delete(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0:     }
sl@0: 
sl@0: TInt TempFilesCount()
sl@0: 	{
sl@0:     _LIT(KServerTempDirMask, "c:\\private\\10281e17\\temp\\*.*");
sl@0: 	CDir* dir = NULL;
sl@0: 	TInt err = TheFs.GetDir(KServerTempDirMask, KEntryAttNormal, ESortNone, dir);
sl@0: 	TEST2(err, KErrNone);
sl@0: 	TInt tmpFileCount = dir->Count();
sl@0: 	delete dir;
sl@0: 	return tmpFileCount;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4211
sl@0: @SYMTestCaseDesc        Test for the change "Temp files created during sql operations are not deleted after rebooting the phone" 
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         The test creates a database and runs a set of statements that
sl@0: 						will lead to a delayed creation of a temp file.
sl@0: 						At the end the test checks that the temp file was created.
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: */
sl@0: void TempFileTest()
sl@0: 	{
sl@0:     (void)RSqlDatabase::Delete(KTestDatabase1);
sl@0:     TInt err = TheDb1.Create(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0:     //Get the number of the files in the SQL temp directory 
sl@0: 	TInt tmpFileCount = TempFilesCount();
sl@0:     //    
sl@0:     err = TheDb1.Exec(_L("CREATE TABLE t1(x UNIQUE); INSERT INTO t1 VALUES(1)"));
sl@0:     TEST(err >= 0);
sl@0:     err = TheDb1.Exec(_L("BEGIN; UPDATE t1 SET x = 2; UPDATE t1 SET x = 3; COMMIT"));
sl@0:     TEST(err >= 0);
sl@0:     //Check that a temp file really was created
sl@0: 	TInt tmpFileCount2 = TempFilesCount();
sl@0: 	TEST(tmpFileCount2 > tmpFileCount);
sl@0:     //
sl@0:     TheDb1.Close();
sl@0:     err = RSqlDatabase::Delete(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4213
sl@0: @SYMTestCaseDesc        Tests the ability of the SQL server to store empty strings and retrieve them as 
sl@0: 						text column values, not NULLs.
sl@0: 						Change: ou1cimx1#504388. 
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         The test creates a database and a table and stores there empty strings.
sl@0: 						Then the test retrieves the stored column values and verifies that the column type is
sl@0: 						"text", not "null".
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: */
sl@0: void EmptyTextColumnTest()
sl@0: 	{
sl@0: 	_LIT8(KEncUtf16, "encoding=\"UTF-16\"");
sl@0: 	_LIT8(KEncUtf8, "encoding=\"UTF-8\"");
sl@0: 	TPtrC8 enc[] = {KEncUtf16(), KEncUtf8()};
sl@0: 	for(TInt i=0;i<(sizeof(enc)/sizeof(enc[0]));++i)
sl@0: 		{
sl@0: 		(void)RSqlDatabase::Delete(KTestDatabase1);
sl@0: 		TInt err = TheDb1.Create(KTestDatabase1, &enc[i]);
sl@0: 		TEST2(err, KErrNone);
sl@0: 		//Insert records with empty text column values using RSqlDatabase::Exec()
sl@0: 	    err = TheDb1.Exec(_L("CREATE TABLE A(ID INTEGER, T TEXT)"));
sl@0: 	    TEST(err >= 0);
sl@0: 	    err = TheDb1.Exec(_L("INSERT INTO A VALUES(1, '')"));
sl@0: 	    TEST2(err, 1);
sl@0: 	    err = TheDb1.Exec(_L8("INSERT INTO A VALUES(2, '')"));
sl@0: 	    TEST2(err, 1);
sl@0: 		//Insert a record with empty text column value using RSqlParamWriteStream
sl@0: 	    RSqlStatement stmt;
sl@0: 	    err = stmt.Prepare(TheDb1, _L("INSERT INTO A(ID, T) VALUES(:P1, :P2)"));
sl@0: 	    TEST2(err, KErrNone);
sl@0: 		err = stmt.BindInt(0, 3);
sl@0: 	    TEST2(err, KErrNone);
sl@0: 	    RSqlParamWriteStream strm;
sl@0: 	    err = strm.BindText(stmt, 1);
sl@0: 	    TEST2(err, KErrNone);
sl@0: 	    TRAP(err, strm.WriteL(KNullDesC));
sl@0: 	    TEST2(err, KErrNone);
sl@0: 	    strm.Close();
sl@0: 	    err = stmt.Exec();
sl@0: 	    TEST2(err, 1);
sl@0: 	    stmt.Close();
sl@0: 		//Insert records with empty text column values using RSqlStatement::Bind()
sl@0: 	    err = stmt.Prepare(TheDb1, _L("INSERT INTO A(ID, T) VALUES(:P1, :P2)"));
sl@0: 	    TEST2(err, KErrNone);
sl@0: 		err = stmt.BindInt(0, 4);
sl@0: 	    TEST2(err, KErrNone);
sl@0: 		err = stmt.BindText(1, KNullDesC);
sl@0: 	    TEST2(err, KErrNone);
sl@0: 	    err = stmt.Exec();
sl@0: 	    TEST2(err, 1);
sl@0: 	    //
sl@0: 	    err = stmt.Reset();
sl@0: 	    TEST2(err, KErrNone);
sl@0: 		err = stmt.BindInt(0, 5);
sl@0: 	    TEST2(err, KErrNone);
sl@0: 	    _LIT(KEmptyStr, "");
sl@0: 		err = stmt.BindText(1, KEmptyStr);
sl@0: 	    TEST2(err, KErrNone);
sl@0: 	    err = stmt.Exec();
sl@0: 	    TEST2(err, 1);
sl@0: 	    stmt.Close();
sl@0: 	    //Read the empty text column values
sl@0: 	    err = stmt.Prepare(TheDb1, _L("SELECT T FROM A"));
sl@0: 	    TEST2(err, KErrNone);
sl@0: 	    TInt cnt = 0;
sl@0: 	    while((err = stmt.Next()) == KSqlAtRow)
sl@0: 	    	{
sl@0: 			++cnt;
sl@0: 			TPtrC val;
sl@0: 			err = stmt.ColumnText(0, val);
sl@0: 			TEST2(err, KErrNone);
sl@0: 			TEST2(val.Length(), 0);
sl@0: 			TSqlColumnType type = stmt.ColumnType(0);
sl@0: 			TEST2(type, ESqlText);
sl@0: 	    	}
sl@0: 	    stmt.Close();
sl@0: 	    TEST2(err, KSqlAtEnd);
sl@0: 	    TEST2(cnt, 5);
sl@0: 	    //
sl@0: 	    TheDb1.Close();
sl@0: 	    err = RSqlDatabase::Delete(KTestDatabase1);
sl@0: 	    TEST2(err, KErrNone);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: @SYMTestCaseID          PDS-SQL-CT-4214
sl@0: @SYMTestCaseDesc        Test for the change "After *#7370# Java apps are not preinstalled again" 
sl@0: @SYMTestPriority        High
sl@0: @SYMTestActions         The test makes sure there are no issues if the temp folder is removed after the server 
sl@0:                         has already started. The test performs the following actions - 
sl@0:                         1. Delete the 'temp' directory.
sl@0:                         2. Create a transaction which creates temp files.
sl@0:                         3. Check 'temp' folder exists at the end
sl@0: @SYMTestExpectedResults Test must not fail
sl@0: */
sl@0: void DeleteTempFolder()
sl@0:     {
sl@0:     //1. Delete 'temp' folder
sl@0:     TInt err = TheFs.RmDir(KServerTempDir);
sl@0:     TEST2(err, KErrNone);
sl@0: 	
sl@0:     //2. Create a transaction which creates temp files.
sl@0:     (void)RSqlDatabase::Delete(KTestDatabase1);
sl@0:     err = TheDb1.Create(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     err = TheDb1.Exec(_L("CREATE TABLE t1(x UNIQUE); INSERT INTO t1 VALUES(1)"));
sl@0:     TEST(err >= 0);
sl@0:     err = TheDb1.Exec(_L("BEGIN; UPDATE t1 SET x = 2; UPDATE t1 SET x = 3; COMMIT"));
sl@0:     TEST(err >= 0);
sl@0:     
sl@0:     TheDb1.Close();
sl@0:     err = RSqlDatabase::Delete(KTestDatabase1);
sl@0:     TEST2(err, KErrNone);
sl@0:     
sl@0:     //3. Check 'temp' folder exists
sl@0:     err = TheFs.MkDir(KServerTempDir);
sl@0:     TEST2(err, KErrAlreadyExists);
sl@0:     }	
sl@0: 	
sl@0: void DoTestsL()
sl@0: 	{
sl@0: 	TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-4154 DEF143062: SQL, \"CREATE INDEX\" sql crashes SQL server"));
sl@0: 	DEF143062();
sl@0: 
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-4155 DEF143061: SQL, SQLITE_DEFAULT_JOURNAL_SIZE_LIMIT value is too big"));
sl@0:     DEF143061();
sl@0: 
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SQL-CT-4156 DEF143150: SQL, strftime() returns incorrect result"));
sl@0:     DEF143150();
sl@0:     
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4210 Temp files created during sql operations are not deleted after rebooting the phone - 1"));
sl@0:     DeleteTempFile();
sl@0:     
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4211 Temp files created during sql operations are not deleted after rebooting the phone - 2"));
sl@0:     TempFileTest();
sl@0:     
sl@0:     TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4213 No support to store an empty string in symbian's sqlite."));
sl@0:     EmptyTextColumnTest();
sl@0: 	
sl@0: 	TheTest.Next(_L(" @SYMTestCaseID:PDS-SQL-CT-4214 After *#7370# Java apps are not preinstalled again"));
sl@0:     DeleteTempFolder();
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: 	CreateTestEnv();
sl@0: 	TRAPD(err, DoTestsL());
sl@0: 	DestroyTestEnv();
sl@0: 	TEST2(err, KErrNone);
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: 	}