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

//

/**

@SYMTestCaseID      PIM-APPENG-CNTM-CNTDB-106281-0001

@SYMTestCaseDesc    The purpose of this test is to verify the expected behaviour

                    of the CContactDatabase public APIs involving invalid database

                    file paths (eg. string length exceeds 190 characters,

                    and string containing path characters)

@SYMTestActions     Passing an empty string, a string with more than 190 characters,

                    and a string containing path into CContactDatabase's public APIs and

                    verify if the expected error code is returned

@SYMTestExpectedResults     Expected all test cases to pass.

@SYMDEF                     DEF106281

@SYMTestType                UT

@SYMTestPriority            Low

*/

#include <cntdb.h>

#include "CCntIpcCodes.h"

#include "t_dbnametest.h"

//===========================================================

// CDbNameTest Class

//===========================================================

CDbNameTest::~CDbNameTest()

    {

    iLongDbName.Close();

    iInvalidDbName.Close();

    if (iActiveSchedulerWait)

        {

        if (iActiveSchedulerWait->IsStarted())

            {

            iActiveSchedulerWait->AsyncStop();

            }

        delete iActiveSchedulerWait;

        }

    iTest->Close();

    delete iTest;

    }

CDbNameTest::CDbNameTest()

    : CActive(EPriorityStandard)

    {

    CActiveScheduler::Add(this);

    }

CDbNameTest* CDbNameTest::NewLC()

    {

    CDbNameTest* self = new (ELeave) CDbNameTest();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

void CDbNameTest::ConstructL()

    {

    iTest = new(ELeave) RTest(_L("T_DBNameTest"));

    // Create invalid DB Name (with wildcard & path characters)

    iInvalidDbName.Create(_L("c:**"));

    }

void CDbNameTest::RunTestsL()

    {

    iTest->Start(_L(" ----------- T_DBNameTest ---------- "));

	RArray<TInt> errArray;

	CleanupClosePushL(errArray);

	//MaxLength	

	errArray.AppendL(KErrNone);  //Create

	errArray.AppendL(KErrNone);     //Open

	errArray.AppendL(KErrNone); //Replace

	errArray.AppendL(KErrNone);    //Delete

	errArray.AppendL(KErrNone);    //Exists

	SetAndTestFileNameL(EMaxLength, errArray);

	//ELessThanMaxLength

	errArray.Reset();	

	errArray.AppendL(KErrNone);  //Create

	errArray.AppendL(KErrNone); //Open

	errArray.AppendL(KErrNone); //Replace

	errArray.AppendL(KErrNone); //Delete

	errArray.AppendL(KErrNone); //Exists

	SetAndTestFileNameL(ELessThanMaxLength, errArray);

	//ENoDriveName

	errArray.Reset();	

	errArray.AppendL(KErrBadName); //Create

	errArray.AppendL(KErrBadName); //Open

	errArray.AppendL(KErrBadName); //Replace

	errArray.AppendL(KErrBadName); //Delete

	errArray.AppendL(KErrBadName); //Exists

	SetAndTestFileNameL(ENoDriveName, errArray);

	//EInvalidFileName

	errArray.Reset();

	errArray.AppendL(KErrBadName); //Create

	errArray.AppendL(KErrBadName); //Open

	errArray.AppendL(KErrBadName); //Replace

	errArray.AppendL(KErrBadName); //Delete

	errArray.AppendL(KErrBadName); //Exists

	SetAndTestFileNameL(EInvalidFileName, errArray);

	//ENullFileName	

	errArray.Reset();

	errArray.AppendL(KErrBadName);  //Create

	errArray.AppendL(KErrBadName);  //Open

	errArray.AppendL(KErrBadName);  //Replace

	errArray.AppendL(KErrNotFound); //Delete (expects no default database in the private directory) 

	errArray.AppendL(KErrNone);     //Exists

	//deleting default database if exists.

	TRAP_IGNORE(CContactDatabase::DeleteDatabaseL(KNullDesC));

	SetAndTestFileNameL(ENullFileName, errArray);

	//EMoreThanMaxLength

	errArray.Reset();

	errArray.AppendL(KErrArgument); //Create

	errArray.AppendL(KErrArgument); //Open

	errArray.AppendL(KErrArgument); //Replace

	errArray.AppendL(KErrArgument); //Delete

	errArray.AppendL(KErrArgument); //Exists

	SetAndTestFileNameL(EMoreThanMaxLength, errArray);

    CleanupStack::PopAndDestroy(); //Releasing memory used by errArray.

    //EMoreThanMaxLength above creates a filename with length more than allowed length, Test Asyncopendatabasetest

    //requires such a file name, so it should be run after above test.

    AsyncOpenDatabaseTest();

    (*iTest) (iFailedTests == 0);

    iTest->End();

    }

void CDbNameTest::AsyncOpenDatabaseTest()

    {

    // open database with long path name

    iTest->Next(_L("TEST 1: CContactDatabase::Open() with long file name"));

    iCurrName.Set(iLongDbName);

    SetActive();

    TRequestStatus* status = &iStatus;

    iOpenOp = CContactDatabase::Open(iLongDbName, *status);

    iActiveSchedulerWait = new (ELeave) CActiveSchedulerWait();

    iActiveSchedulerWait->Start();

    }

void CDbNameTest::AsyncOpenDatabaseNullTestL()

    {

    // open database with NULL path name

    iTest->Next(_L("TEST 2: CContactDatabase::Open() with NULL file name."));

    iCurrName.Set(KNullDesC);

    SetActive();

    TRequestStatus* status = &iStatus;

    iOpenOp = CContactDatabase::Open(KNullDesC, *status);

    }

void CDbNameTest::AsyncOpenDatabaseInvalidTest()

    {

    // open database with invalid path name

    iTest->Next(_L("TEST 3: CContactDatabase::Open() with file name containing path or wildcard characters."));

    iCurrName.Set(iInvalidDbName);

    SetActive();

    TRequestStatus* status = &iStatus;

    iOpenOp = CContactDatabase::Open(iInvalidDbName, *status);

    }

void CDbNameTest::RunL()

    {

    TInt err = iStatus.Int();

    if (iOpenOp)

        {

        if (err == KErrNone)

            {

            // if the database has been successfully opened, close it

            CContactDatabase* database = iOpenOp->TakeDatabase();

            if (database)

                {

                delete database;

                }

            }

        delete iOpenOp;

        iOpenOp = NULL;

        }

    if (iLongDbName == iCurrName)

        {

        if (err != KErrArgument)

            {

            iFailedTests++;

            iTest->Printf(_L("-> FAILED - invalid error code returned-- %d.\n"), err);

            }

        // Proceed to test 2

        AsyncOpenDatabaseNullTestL();

        }

    else if (iCurrName.Length() == 0)

        {

        // Asyc Open treats a NULL database path as the default database.

        // Therefore, both KErrNone, (meaning a default database exists), and 

        // KErrNotFound, (meaning the default database not yet exist), are acceptable

        // error codes.

        if (err != KErrNone && err != KErrNotFound)

            {

            iFailedTests++;

            iTest->Printf(_L("-> FAILED - invalid error code returned-- %d.\n"), err);

            }

        // Process to last test

        AsyncOpenDatabaseInvalidTest();

        }

    else

        {

        if (err != KErrBadName)

            {

            iFailedTests++;

            iTest->Printf(_L("-> FAILED - invalid error code returned-- %d.\n"), err);

            }

        iActiveSchedulerWait->AsyncStop();

        }

    }

/**

@SYMTestCaseID      		PIM-DBNAMETEST-0001

@SYMTestCaseDesc    		Attempts to test the behaviour of Contactdatabse API's

							while Opening, Deleting, Creating, Replacing a filename of different types. 

@SYMTestActions     		1)Create a filename, it can be of different types.

							2)Try to perform Create,Open,Delete,Replace on that filename.

							3)Check if it returns a correct errorcode.						

@SYMTestExpectedResults     Expected all test cases to pass.

@SYMDEF                     DEF114180

@SYMTestType                UT

@SYMTestPriority            Low

*/

void CDbNameTest::SetAndTestFileNameL(TFileNameType aType, RArray<TInt>& aErrArray)

	{

	_LIT16(KDrive,"c:");

	TBool driveName = ETrue;

	TBool invalidFileName = EFalse;

	TBool createFilename = ETrue;

	TBool nullFilename = EFalse;

	TInt nameLength = 0;

	switch (aType)

		{

		case ENoDriveName:

			{

			iTest->Next(_L("\n*****Operations without Drive name.*****"));

			nameLength = 50;

			driveName = EFalse;	

			}

		break;

		case EMoreThanMaxLength:

			{

			iTest->Next(_L("\n*****Operations with Filename more than maximum allowed length.*****"));

			nameLength = 200;	

			}

		break;

		case EMaxLength:

			{

			iTest->Next(_L("\n*****Operations with Filename having maximum allowed length.*****"));

			nameLength = 190;	

			}

		break;

		case ELessThanMaxLength:

			{

			iTest->Next(_L("\n*****Operations with Filename length less than maximum allowed length.*****"));

			nameLength = 100;	

			}

		break;

		case  EInvalidFileName:

			{

			iTest->Next(_L("\n*****Operations with Invalid Filename.*****"));

			invalidFileName = ETrue;

			createFilename = EFalse;

			driveName = EFalse;

			nameLength = 5;	

			}

		break;

		case ENullFileName:

			{

			iTest->Next(_L("\n*****Operations with NULL Filename.*****"));			

			nullFilename = ETrue;

			createFilename = EFalse;

			driveName = EFalse;	

			}

		break;	

		default:

		User::Leave(KErrArgument);

		}

	iLongDbName.Close();

	iLongDbName.CreateL(nameLength);

	if(driveName)

		{

		iLongDbName.Append(KDrive);	

		}

	if(invalidFileName)

		{

		iLongDbName = iInvalidDbName;	

		}

	if(nullFilename)

		{

		iLongDbName.Append(KNullDesC);	

		}

	if(createFilename)

		{

	    for (TInt i = 1; i < iLongDbName.MaxLength()-2; i++)

	        {

	        TChar ch('a');

	        ch += i % 26;

	        iLongDbName.Append(ch);

	        }		

		}

	TInt typeOfTests = 5;

 	for(TInt loop = 0;loop < typeOfTests ; ++loop)

	 	{

	 	CContactDatabase* db = NULL;

	 	TInt err(0);

	 	TInt typeOfError(0);

	 	switch(loop)

	 	{

	 		case 0:   // CREATE DATABASE TEST

	 	 		{

		 		iTest->Printf(_L("TEST : CContactDatabase::CreateL() ."));

		    	TRAP(err, db = CContactDatabase::CreateL(iLongDbName));

		    	if (err == aErrArray[0])

			    	{

			    	typeOfError = 1;					

			    	}

		    	else if(err == KErrAlreadyExists || err == KErrBadName || err == KErrDiskFull || err == KErrArgument)

			    	{

			     	typeOfError = 2;	

			    	}

				} 

	     	break;

	 		case 1:	  // OPEN DATABASE TEST

		 		{

		 		iTest->Printf(_L("TEST : CContactDatabase::OpenL()."));

		    	TRAP(err, db = CContactDatabase::OpenL(iLongDbName));

		    	if (err == aErrArray[1])

			    	{

			    	typeOfError = 1;					

			    	}

		    	else if(err == KErrNotFound || err == KErrLocked || err == KErrBadName || err == KErrDiskFull || err == KErrArgument)

			    	{

			     	typeOfError = 2;	

			    	}		    	

				}    	

	 		break;

	 		case 2:  // REPLACE DATABASE TEST

		 		{

		 		iTest->Printf(_L("TEST : CContactDatabase::ReplaceL()()."));

		    	TRAP(err, db = CContactDatabase::ReplaceL(iLongDbName));

		    	if (err == aErrArray[2])

			    	{

			    	typeOfError = 1;					

			    	}

		    	else if(err == KErrInUse || err == KErrBadName || err == KErrDiskFull || err == KErrArgument)

			    	{

			     	typeOfError = 2;	

			    	}		    	

				}  		

	 		break;

	 		case 3:  // DELETE DATABASE TEST

	 	 		{

		 		iTest->Printf(_L("TEST : CContactDatabase::DeleteDatabaseL()."));

		    	TRAP(err, CContactDatabase::DeleteDatabaseL(iLongDbName));

		    	if (err == aErrArray[3])

			    	{

			    	typeOfError = 1;					

			    	}

		    	else if(err == KErrNotFound || err == KErrBadName || err == KErrInUse || err == KErrArgument)

			    	{

			     	typeOfError = 2;	

			    	}		    	

				} 		

	 		break;

	 		case 4:  // DATABASE EXISTS TEST

	 	 		{

		 		iTest->Printf(_L("TEST : CContactDatabase::ContactDatabaseExistsL()."));

		    	TRAP(err, CContactDatabase::ContactDatabaseExistsL(iLongDbName));

		    	if (err == aErrArray[4])

			    	{

			    	typeOfError = 1;					

			    	}

		    	else if(err == KErrNotReady || err == KErrBadName || err == KErrNotFound || err == KErrArgument || err == KErrCorrupt)

			    	{

			     	typeOfError = 2;	

			    	}		    	

				} 		

	 		break;

	 		default:

	 			User::Leave(KErrArgument);

	 		break;	 		

	 	}

	 	if(typeOfError == 1)

		 	{

			iTest->Printf(_L("Correct Error Code Returned: %d"), err);

		 	}

	 	else if(typeOfError == 2)

		 	{

			iTest->Printf(_L("Incorrect, but one of the possible error codes returned: %d"), err);

		 	}

	 	else

		 	{

			iTest->Printf(_L("ERROR:- Test Failed, Unexpected Error Code returned: %d"), err);

		 	}

	    if (db)

	        {

	        delete db;

	        }

	  	}  	

	}

LOCAL_C void DoTestsL()

    {

    CDbNameTest* test = CDbNameTest::NewLC();

    test->RunTestsL();

    CleanupStack::PopAndDestroy(test);

    }

GLDEF_C TInt E32Main()

    {

    // Init

    CTrapCleanup* cleanupStack = CTrapCleanup::New();

    if (!cleanupStack)

        {

        return KErrNoMemory;

        }

    CActiveScheduler* activeScheduler = new CActiveScheduler;

    if (!activeScheduler)

        {

        return KErrNoMemory;

        }

    CActiveScheduler::Install(activeScheduler);

    // Run the tests

    __UHEAP_MARK;

    TRAPD(err, DoTestsL());

    __UHEAP_MARKEND;

    // Cleanup

    delete activeScheduler;

    delete cleanupStack;

    return err;

    }