// Copyright (c) 2010 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:

//

#include <e32test.h>

#include <bautils.h>

#include "SqlSrvMain.h"

#include "SqlSrvStartup.h"

#include "SqlSrvUtil.h"

_LIT(KCfgDb1ConfigFilePath, "c:\\private\\10281e17\\cfg[10281E17]t_sqlstartup1.db.02"); // config file version 2 for t_sqlstartup1.db

_LIT(KCfgDb2ConfigFilePath, "c:\\private\\10281e17\\cfg[10281E17]t_sqlstartup2.db.05"); // config file version 5 for t_sqlstartup2.db

//This subdir is created by t_sqlenvcreate app. It should not be returned in the list of files for backup.

_LIT(KPrivateSubDir, "c:\\private\\10281e17\\TestDir.db");

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

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

RFs TheFs;

static TInt TheProcessHandleCount = 0;

static TInt TheThreadHandleCount = 0;

static TInt TheAllocatedCellsCount = 0;

#ifdef _DEBUG

static const TInt KBurstRate = 20;

#endif

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

void DeleteTestFiles()

	{

	(void)TheFs.Delete(KCfgDb2ConfigFilePath);

	(void)TheFs.Delete(KCfgDb1ConfigFilePath);

	TheFs.Close();

	}

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

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

//Test macros and functions

void Check(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		DeleteTestFiles();

		RDebug::Print(_L("*** Expresssion evaluated to false\r\n"));

		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__)

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

static void MarkHandles()

    {

    RThread().HandleCount(TheProcessHandleCount, TheThreadHandleCount);

    }

static void MarkAllocatedCells()

    {

    TheAllocatedCellsCount = User::CountAllocCells();

    }

static void CheckAllocatedCells()

    {

    TInt allocatedCellsCount = User::CountAllocCells();

    TEST2(allocatedCellsCount, TheAllocatedCellsCount);

    }

static void CheckHandles()

    {

    TInt endProcessHandleCount;

    TInt endThreadHandleCount;

    RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

    TEST2(TheProcessHandleCount, endProcessHandleCount);

    TEST2(TheThreadHandleCount, endThreadHandleCount);

    }

static void OomPreStep(TInt

#ifdef _DEBUG        

    aFailingAllocationNo

#endif

                      )

    {

    MarkHandles();

    MarkAllocatedCells();

    __UHEAP_MARK;

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

    }

static void OomPostStep()

    {

    __UHEAP_RESET;

    __UHEAP_MARKEND;

    CheckAllocatedCells();

    CheckHandles();

    }

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

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

static void CreateAndDestroySqlServerL()

    {

    CSqlServer* server = CSqlServer::NewLC();

    //Drive C: to the RSqlDriveSpaceCol object. This will allow "reserve drive space" construct/destroy code to be tested.  

    RSqlDriveSpaceCol& drvcol = server->DriveSpaceCol();

    drvcol.AddL(EDriveC);

    CleanupStack::PopAndDestroy(server);

    }

static CSqlServer* CreateSqlServerL()

    {

    CSqlServer* server = CSqlServer::NewLC();

    CleanupStack::Pop(server);

    return server;

    }

/**

@SYMTestCaseID          PDS-SQL-UT-4159

@SYMTestCaseDesc        SQL server startup OOM test

@SYMTestPriority        High

@SYMTestActions         Runs the SQL server startup code in an OOM loop.

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144096

*/  

void SqlServerStartupOomTest()

    {

    TInt err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo);

        TRAP(err, CreateAndDestroySqlServerL());

        OomPostStep();

        }

    if(err != KErrNoMemory)

        {

        TEST2(err, KErrNone);   

        }

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\n"), failingAllocationNo);

    }

/**

@SYMTestCaseID          PDS-SQL-UT-4160

@SYMTestCaseDesc        CSqlServer::GetBackUpListL() OOM test

@SYMTestPriority        High

@SYMTestActions         Calls CSqlServer::GetBackUpListL() in an OOM loop.

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144096

*/  

void GetBackupListOomTest()

    {

    CSqlServer* server = NULL;

    TRAPD(err, server = CreateSqlServerL());

    TEST2(err, KErrNone);

    TInt fileCnt = 0;

    err = KErrNoMemory;

    TInt failingAllocationNo = 0;

    TheTest.Printf(_L("Iteration:\r\n"));

    while(err == KErrNoMemory)

        {

        TheTest.Printf(_L(" %d"), ++failingAllocationNo);

        OomPreStep(failingAllocationNo);

        const TUid KDbUd = {0x98765432};

        RArray<HBufC*> files;

        TRAP(err, server->GetBackUpListL(KDbUd, EDriveC, files));

        fileCnt = files.Count();

        if(err == KErrNone)

        	{

			//No directories should be returned in the list of files for backup

			for(TInt i=0;i<fileCnt;++i)

				{

				TPtrC fname = files[i]->Des();

				TInt rc = KPrivateSubDir().CompareF(fname);

				TEST(rc != 0);

				}

        	}

        for(TInt j=0;j<files.Count();++j)

        	{

			delete files[j];

        	}

        files.Close();

        OomPostStep();

        }

    delete server;

    if(err != KErrNoMemory)

        {

        TEST2(err, KErrNone);   

        }

    TheTest.Printf(_L("\r\n===OOM test succeeded at heap failure rate of %d ===\r\nFile count: %d\r\n"), failingAllocationNo, fileCnt);

    }

/**

@SYMTestCaseID          PDS-SQL-UT-4161

@SYMTestCaseDesc        SQL server startup file I/O error simulation test

@SYMTestPriority        High

@SYMTestActions         Runs the SQL server startup code in a file I/O error simulation loop.

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144096

*/  

void SqlServerStartupFileIoErrorTest()

    {

    RFs fs;

    TInt err = fs.Connect();

    TEST2(err, KErrNone);

    for(TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)

        {

        TheTest.Printf(_L("===Simulated error: %d\r\nIteration: "), fsError);

        err = KErrNotFound;

        TInt cnt=0;

        while(err<KErrNone)

            {

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

            (void)fs.SetErrorCondition(fsError, cnt);

            TRAP(err, CreateAndDestroySqlServerL());

            (void)fs.SetErrorCondition(KErrNone);

            if(err != KErrNone)

                {

                ++cnt;

                }

            }

        TEST2(err, KErrNone);

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

        }

    fs.Close();

    }

/**

@SYMTestCaseID          PDS-SQL-UT-4162

@SYMTestCaseDesc        CSqlServer::GetBackUpListL() file I/O error simulation test

@SYMTestPriority        High

@SYMTestActions         Calls CSqlServer::GetBackUpListL() in a file I/O error simulation loop.

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144096

*/  

void GetBackupListFileIoErrorTest()

    {

    CSqlServer* server = NULL;

    TRAPD(err, server = CreateSqlServerL());

    TEST2(err, KErrNone);

    for(TInt fsError=KErrNotFound;fsError>=KErrBadName;--fsError)

        {

        TheTest.Printf(_L("===Simulated error: %d\r\nIteration: "), fsError);

        err = KErrNotFound;

        TInt fileCnt = 0;

        TInt cnt=0;

        while(err<KErrNone)

            {

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

            (void)server->Fs().SetErrorCondition(fsError, cnt);

            const TUid KDbUd = {0x98765432};

            RArray<HBufC*> files;

            TRAP(err, server->GetBackUpListL(KDbUd, EDriveC, files));

            fileCnt = files.Count(); 

            if(err == KErrNone)

            	{

    			//No directories should be returned in the list of files for backup

    			for(TInt i=0;i<fileCnt;++i)

    				{

    				TPtrC fname = files[i]->Des();

    				TInt rc = KPrivateSubDir().CompareF(fname);

    				TEST(rc != 0);

    				}

            	}

            for(TInt j=0;j<files.Count();++j)

            	{

				delete files[j];

            	}

            files.Close();

            (void)server->Fs().SetErrorCondition(KErrNone);

            if(err != KErrNone)

                {

                ++cnt;

                }

            }

        TEST2(err, KErrNone);

        TheTest.Printf(_L("\r\n===File I/O error simulation test succeeded on iteration %d===\r\nFile count: %d\r\n"), cnt, fileCnt);

        }

    delete server;

    }

/**

@SYMTestCaseID          PDS-SQL-UT-4224

@SYMTestCaseDesc        CSqlServer::GetBackUpListL() functional test

@SYMTestPriority        High

@SYMTestActions         Calls CSqlServer::GetBackUpListL() and tests the output, when the drive is read-only,

                        when there is a sub-directory which name is matching the search pattern.

@SYMTestExpectedResults Test must not fail

*/  

void GetBackupListFunctionalTest()

	{

    CSqlServer* server = NULL;

    TRAPD(err, server = CreateSqlServerL());

    TEST2(err, KErrNone);

    //Case 1: database with specified uid bellow do exist (on drive C). There will be one subdirectory matching the search pattern. 

    const TDriveNumber KTestDrvNum1 = EDriveC;

    const TUid KDbUid = {0x98765432};

	TDriveUnit testDrive(KTestDrvNum1);

	TDriveName testDriveName = testDrive.Name();

	testDriveName.LowerCase(); 

	//One test directory will be created, which name will be matching the search pattern.

	//The directory name should not be included in the list with the file names.

    TFileName testFileName;

    err = server->Fs().PrivatePath(testFileName);

    TEST2(err, KErrNone);

    testFileName.Append(KDbUid.Name());

    _LIT(KTestPath, "t_startup\\");

    testFileName.Append(KTestPath);

    testFileName.Append(_L("t_startup.db"));

    TParse parse;

    err = parse.Set(testFileName, &testDriveName, 0);

    TEST2(err, KErrNone);

    err = server->Fs().MkDirAll(parse.FullName());

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

    //

    RArray<HBufC*> files;

    TRAP(err, server->GetBackUpListL(KDbUid, KTestDrvNum1, files));

    TEST2(err, KErrNone);

    TInt fileCnt = files.Count();

    for(TInt i=0;i<fileCnt;++i)

    	{

		TPtrC fname = files[i]->Des();

		TheTest.Printf(_L("Db: %S\r\n"), &fname);

		TEST(fname.FindF(KTestPath) < 0);

		//The name should include the full path + the drive

		err = parse.Set(fname, 0, 0);

		TEST2(err, KErrNone);

		TEST(parse.DrivePresent());

		TEST(parse.PathPresent());

		TDriveName driveName(parse.Drive());

		driveName.LowerCase(); 

		delete files[i];

		TEST(driveName == testDriveName);		

    	}

    files.Close();

    //Case 2: drive Z:. No files should be returned.

    const TDriveNumber KTestDrvNum2 = EDriveZ;

    TRAP(err, server->GetBackUpListL(KDbUid, KTestDrvNum2, files));

    TEST2(err, KErrNone);

    fileCnt = files.Count();

    TEST2(fileCnt, 0);

    //Case 3: drive A:. The drive does not exist. No files should be returned.

    const TDriveNumber KTestDrvNum3 = EDriveA;

    TRAP(err, server->GetBackUpListL(KDbUid, KTestDrvNum3, files));

	TheTest.Printf(_L("Drive %d, err=%d\r\n"), KTestDrvNum3, err);

    fileCnt = files.Count();

    TEST2(fileCnt, 0);

    //

    delete server;

	}

/**

@SYMTestCaseID          PDS-SQL-UT-4163

@SYMTestCaseDesc        Test for DEF144196: SQL, server code coverage can be improved

@SYMTestPriority        High

@SYMTestActions         Tests the UTF conversion functions implemented in SqlSrvUtil.cpp.

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144196

*/  

void UtfConversionTest()

    {

    /////////       UTF16ToUTF8()       ///////////////////////

    _LIT(KStr16, "abcd");

    _LIT8(KStr8, "abcd");

    TBuf8<KMaxFileName + 1> bufout;

    TBool rc = UTF16ToUTF8(KStr16, bufout);

    TEST(rc);

    TEST(bufout == KStr8);

    //Test where the input buffer contains non-convertible characters

    TBuf<2> name2;

    name2.SetLength(2);

    name2[0] = TChar(0xD800); 

    name2[1] = TChar(0xFC00); 

    rc = UTF16ToUTF8(name2, bufout);

    TEST(!rc);

    /////////       UTF16ToUTF8Z()       ///////////////////////

    _LIT8(KStr8Z, "abcd\x0");

    rc = UTF16ToUTF8Z(KStr16, bufout);

    TEST(rc);

    TEST(bufout == KStr8Z);

    //Test where the input buffer contains non-convertible characters

    rc = UTF16ToUTF8Z(name2, bufout);

    TEST(!rc);

    /////////       UTF16ZToUTF8Z()       ///////////////////////

    _LIT(KStr16Z, "abcd\x0");

    rc = UTF16ZToUTF8Z(KStr16Z, bufout);

    TEST(rc);

    TEST(bufout == KStr8Z);

    //Test where the input buffer contains non-convertible characters

    TBuf<3> name3;

    name3.SetLength(3);

    name3[0] = TChar(0xD800); 

    name3[1] = TChar(0xFC00); 

    name3[2] = TChar(0x0000); 

    rc = UTF16ZToUTF8Z(name3, bufout);

    TEST(!rc);

    }

/**

@SYMTestCaseID          PDS-SQL-UT-4175

@SYMTestCaseDesc        Test for DEF144937: SQL, SQL server, the code coverage can be improved in some areas. 

@SYMTestPriority        High

@SYMTestActions         The test creates a SQL server instance and performs some basic operations with

                        RSqlDriveSpaceCol object owned by the server, such as: adding a new drive,

                        getting an access to the reserved drive space, releasing the access.

@SYMTestExpectedResults Test must not fail

@SYMDEF                 DEF144937

*/  

void ReserveDriveSpaceTest()

    {

    CSqlServer* srv = NULL;

    TRAPD(err, srv = CreateSqlServerL());

    TEST2(err, KErrNone);

    RSqlDriveSpaceCol& drvcol = srv->DriveSpaceCol();

    TRAP(err, drvcol.AddL(EDriveC));

    TEST2(err, KErrNone);

    CSqlDriveSpace* drvspace = drvcol.Find(EDriveZ);

    TEST(!drvspace);

    drvspace = drvcol.Find(EDriveC);

    TEST(drvspace != NULL);

    TDriveNumber drvnum = drvspace->Drive();

    TEST2(drvnum, EDriveC);

    //It is safe to call GetAccessL() more than once. The access is reference counted.

    TRAP(err, drvspace->GetAccessL());

    TEST2(err, KErrNone);

    TRAP(err, drvspace->GetAccessL());

    TEST2(err, KErrNone);

    //It is safe if ReleaseAccess() call count do not match GetAccessL() call count.

    drvspace->ReleaseAccess();

    drvspace->ReleaseAccess();

    drvspace->ReleaseAccess();

    //

    drvcol.ResetAndDestroy();

    delete srv;

    }

void DoCreateCfgFile(const TDesC& aFileName, const TDesC8& aData)

    {

    RFile file;

    TInt err = file.Create(TheFs, aFileName, EFileRead | EFileWrite);

    TEST2(err, KErrNone);

    err = file.Write(aData); 

    file.Close();   

    TEST2(err, KErrNone);

    }

void DoTests()

	{

    CActiveScheduler* scheduler = new CActiveScheduler;

    TEST(scheduler != NULL);

    CActiveScheduler::Install(scheduler);

    //Adding two db config files will allow CDbConfigFiles construct/destroy code also to be tested in the OOM tests.

    TInt err = TheFs.Connect();

    TEST2(err, KErrNone);

    DoCreateCfgFile(KCfgDb1ConfigFilePath, _L8("CREATE INDEX idx ON table1(i1);"));

    DoCreateCfgFile(KCfgDb2ConfigFilePath, _L8("CREATE INDEX idx1 ON table1(i1);CREATE INDEX idx2 ON table2(i2)"));

    TheTest.Start(_L(" @SYMTestCaseID:PDS-SQL-UT-4159 SQL server startup OOM test"));

    SqlServerStartupOomTest();

    TheTest.Next (_L(" @SYMTestCaseID:PDS-SQL-UT-4160 CSqlServer::GetBackUpListL() OOM test"));

    GetBackupListOomTest();

    TheTest.Next (_L(" @SYMTestCaseID:PDS-SQL-UT-4161 SQL server startup file I/O error simulation test"));

    SqlServerStartupFileIoErrorTest();

    TheTest.Next (_L(" @SYMTestCaseID:PDS-SQL-UT-4162 CSqlServer::GetBackUpListL() file I/O error simulation test"));

    GetBackupListFileIoErrorTest();

    TheTest.Next (_L(" @SYMTestCaseID:PDS-SQL-UT-4224 CSqlServer::GetBackUpListL() functional test"));

    GetBackupListFunctionalTest();

    TheTest.Next (_L(" @SYMTestCaseID:PDS-SQL-UT-4163 SQL server, UTF conversion test"));

    UtfConversionTest();

    TheTest.Next (_L(" @SYMTestCaseID:PDS-SQL-UT-4175 Reserve drive space tests"));

    ReserveDriveSpaceTest();

    delete scheduler;

	}

TInt E32Main()

	{

	TheTest.Title();

	CTrapCleanup* tc = CTrapCleanup::New();

	TheTest(tc != NULL);

	__UHEAP_MARK;

	DoTests();

	DeleteTestFiles();

	__UHEAP_MARKEND;

	TheTest.End();

	TheTest.Close();

	delete tc;

	User::Heap().Check();

	return KErrNone;

	}