// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

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

 // which accompanies this distribution, and is available

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

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 /**

 Instructions:

 This is a manual test created to verify DEFXXXXX, 2 executables needs to be run to do this test

 1) t_sqlfilesrvcrash1.exe - Generate a corrupted journal file, this will cause the device to reset. 

 2) t_sqlfilesrvcrash2.exe - After the reboot, tests if SQL can handle the courrpted journal file.

 This test requires a non-rugged drive to store the database file and therefore will only work in hardware mode

 */

 #include <e32test.h>

 #include <f32file.h>

 #include <sqldb.h>

 RTest TheTest(_L("t_sqlfilesrvcrash1 test"));

 #if !defined __WINS__ && !defined __WINSCW__

 RFs TheFs;

 RSqlDatabase TheDb;

 const TInt KControlIoRuggedOn=2;

 const TInt KControlIoRuggedOff=3;

 const TInt KControlIoIsRugged=4;

 const TChar KDrvLetter = ('E');

 _LIT(KTestDir, "E:\\test\\");

 _LIT(KDbName, "E:\\test\\t_sqlfilesrvcrash.db");

 _LIT8(KConfigStr, "page_size=32768");

 _LIT(KFileSrvName, "efile.exe");

 ///////////////////////////////////////////////////////////////////////////////////////

 //Deletes all created test files.

 void DeleteTestFiles()

     {

     TheDb.Close();

     (void)RSqlDatabase::Delete(KDbName);

     }

 ///////////////////////////////////////////////////////////////////////////////////////

 //Test macros and functions

 void Check(TInt aValue, TInt aLine)

     {

     if(!aValue)

         {

         DeleteTestFiles();

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

         TheTest(EFalse, aLine);

         }

     }

 void Check(TInt aValue, TInt aExpected, TInt aLine)

     {

     if(aValue != aExpected)

         {

         DeleteTestFiles();

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

         TheTest(EFalse, aLine);

         }

     }

 #define TEST(arg) ::Check((arg), __LINE__)

 #define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

 ///////////////////////////////////////////////////////////////////////////////////////

 //Set the drive to Rugged or non-rugged depending on the input parameter

 void SetDrive(TBool aSetToRugged)

     {

     TUint8 isRugged;

     TPtr8 pRugged(&isRugged,1,1);

     TInt drvNum;

     TInt err = TheFs.CharToDrive(KDrvLetter, drvNum);

     TEST2(err, KErrNone);

     err=TheFs.ControlIo(drvNum,KControlIoIsRugged,pRugged);

     TEST2(err, KErrNone);

     if(!aSetToRugged)

         {

         if(isRugged)

             {

             err=TheFs.ControlIo(drvNum,KControlIoRuggedOff);

             TEST2(err, KErrNone);

             }

         }

     else

         {

         if(!isRugged)

             {

             err=TheFs.ControlIo(drvNum,KControlIoRuggedOn);

             TEST2(err, KErrNone);

             }

         }

     }

 //Creates file session instance and the test directory

 void CreateTestEnv()

     {

     TInt err = TheFs.Connect();

     TEST2(err, KErrNone);

     //Set the drive to non-rugged

     TBool setDriveToRugged = EFalse;

     SetDrive(setDriveToRugged);

     err = TheFs.MkDir(KTestDir);

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

     }

 TInt KillProcess(const TDesC& aProcessName)

     {

     TFullName name;

     //RDebug::Print(_L("Find and kill \"%S\" process.\n"), &aProcessName);

     TBuf<64> pattern(aProcessName);

     TInt length = pattern.Length();

     pattern += _L("*");

     TFindProcess procFinder(pattern);

     while (procFinder.Next(name) == KErrNone)

         {

         if (name.Length() > length)

             {//If found name is a string containing aProcessName string.

             TChar c(name[length]);

             if (c.IsAlphaDigit() ||

                 c == TChar('_') ||

                 c == TChar('-'))

                 {

                 //RDebug::Print(_L(":: Process name: \"%S\".\n"), &name);

                 continue;

                 }

             }

         RProcess proc;

         if (proc.Open(name) == KErrNone)

             {

             RDebug::Print(_L("About to kill process \"%S\", This will force a reboot\n"), &name);

             proc.Kill(0);

             }

         proc.Close();

         }

     return KErrNone;

     }

 /**

 @SYMTestCaseID          PDS-SQL-CT-4164

 @SYMTestCaseDesc        Tests for DEF144027: SQL Open returns error if the reported and actual file size are different

                         This function creates a corrupted jorunal file on a non-rugged FAT, where the actual and 

                         reported file size is different. This is done by killing the file server forcing the device to 

                         reset. After the reset t_sqlfilesrvcrash2.exe is used to verify SQL can handle this corrupted

                         journal file properly.

 @SYMTestActions         DEF144027: SQL Open returns error if the reported and actual file size are different

 @SYMTestExpectedResults Test must not fail

 @SYMTestPriority        Medium

 @SYMDEF                 DEF144027

                         DEF144238

 */

 void DEF144027()

 	{

     TInt err = TheDb.Create(KDbName, &KConfigStr);

     TEST2(err, KErrNone);

     err = TheDb.Exec(_L("CREATE TABLE t1(NUM INTEGER)"));

     TEST2(err, 1);

     err = TheDb.Exec(_L("CREATE TABLE t2(NUM INTEGER)"));

     TEST2(err, 1);

     err = TheDb.Exec(_L("INSERT INTO t1(NUM) VALUES (1)"));

     TEST2(err, 1);

     err = TheDb.Exec(_L("INSERT INTO t2(NUM) VALUES (1)"));

     TEST2(err, 1);

     TheDb.Close();

     err = TheDb.Open(KDbName);

     TEST2(err, KErrNone);

     err = TheDb.Exec(_L("BEGIN"));

     TEST(err >= 0);

     err = TheDb.Exec(_L("CREATE TABLE t3(NUM INTEGER)"));

     TEST2(err, KErrNone);

     err = TheDb.Exec(_L("INSERT INTO t1(NUM) VALUES (1)"));

     TEST2(err, 1);

     err = TheDb.Exec(_L("INSERT INTO t2(NUM) VALUES (1)"));

     TEST2(err, 1);

     err = TheDb.Exec(_L("INSERT INTO t3(NUM) VALUES (1)"));

     TEST2(err, 1);

     //Here the transaction is committed but the database is not close

     //this makes sure that the journal is truncated but not deleted 

     err = TheDb.Exec(_L("COMMIT"));

     TEST(err >= 0);

     //Reset the drive to rugged

     TBool setDriveToRugged = ETrue;

     SetDrive(setDriveToRugged);

     //When the file server is killed, the file size meta data will not be updated

     KillProcess(KFileSrvName);  

 	}

 void DoTests()

     {    

     TheTest.Start(_L(" @SYMTestCaseID:PDS-SQL-CT-4164 DEF144027: SQL Open returns error if the reported and actual file size are different"));

     DEF144027();    

     }

 #endif //#if !defined __WINS__ && !defined __WINSCW__

 TInt E32Main()

     {

     TheTest.Title();

     CTrapCleanup* tc = CTrapCleanup::New();

     __UHEAP_MARK;

 #if !defined __WINS__ && !defined __WINSCW__

     CreateTestEnv();

     DeleteTestFiles();

     DoTests();

     TheFs.Close();

     TheTest.End();

 #else

     TheTest.Start(_L("This test works only works on hardware!"));

     TheTest.End();

 #endif  

     __UHEAP_MARKEND;

     TheTest.Close();

     delete tc;

     User::Heap().Check();

     return KErrNone;

     }