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

//

#include "caltestlib.h"

#include "caltestoom.h"

#include <calsession.h>

#include <e32test.h>

#include <calcalendarinfo.h>

#include <calcalendariterator.h>

#include <calentry.h>

#include <calentryview.h>

#include <calalarm.h>

#include <asclisession.h>

#include <asshdalarm.h>

RTest test(_L("tcal_calendarinfo"));

_LIT8(KGUID,  "A_Global_UID");

_LIT8(KGUID1, "A_Global_UID1");

_LIT8(KGUID2, "A_Global_UID2");

_LIT8(KGUID3, "A_Global_UID3");

_LIT(KCalendarFile, "tcal_calendarinfo");

_LIT(KCalendarFileExpected, "c:tcal_calendarinfo");

_LIT(KCalendarFilePrivatePath, "c:\\private\\10003a5b\\tcal_calendarinfo");

// calendar info values

_LIT(KCalendarName, "Calendar");

_LIT(KCalendarDescription, "This is a calendar");

const TRgb KCalendarColor(0xD7, 0x10, 0x01, 0xFF);

const TBool KCalendarEnabled(ETrue);

_LIT8(KPropertyTimeKey, "time");

const TTime KPropertyTimeValue(TDateTime(2007, EMarch, 5, 12, 30, 0, 0));

_LIT8(KPropertyStringKey, "string");

_LIT8(KPropertyStringValue, "Here is some 8 bit text.");

_LIT8(KPropertyIntKey, "int");

const TInt KPropertyIntValue(34);

class CTestManager : public CBase, public MCalTestOomCallBack

	{

private:

    enum

        {

        EOomTestCaseCreateCalFileWithInfo,

        EOomTestCaseSetInfoOnFileWithoutInfo,

        EOomTestCaseUpdateInfo,

        EOomTestCaseFetchInfo,

        EOomTestCaseIterateOverAllInfo,

        EOomTestCaseLast

        };

public:

	static CTestManager* NewLC();

	~CTestManager();

	void RunTestsL();

private:

	CTestManager();

	void ConstructL();

	static void CleanupDeleteCalFile(TAny* aRef);

private: // from MCalTestOomCallBack

	void OomTestL(TType aType, TInt aFailAt);

	void AddEntryWithAlarmL(const TTime& aStartTime, TInt aAlarmMinutes, HBufC8* aGuid, TBool aFloating);

private: // tests ...

    void TestCreateFileWithMetaDataL();

    void TestSetMetaDataL();

    void TestGetMetaDataL();

    void TestGetAllMetaDataL();

    void TestOomL();

    void TestAlarmStatusChangeL();

    void TestAlarmStatusWithAgendaShutDownL();

    void TestSetAndUpdatePropertyL();

    void TestGetPropertyL();

    void TestRemovePropertyL();

    void TestReplaceMetadataL();

private:

	CCalTestLibrary* iTestLibrary; // need a connection to a session to create a CCalEntry

	TCalFileId iFileId;

	RASCliSession      iAlarmServer;

	TInt iOomTestCase;

	};

CTestManager* CTestManager::NewLC()

	{

	CTestManager* self = new (ELeave) CTestManager;

	CleanupStack::PushL(self);

	self->ConstructL();

	// CleanupStack::Pop(self);

	return (self);

	}

CTestManager::CTestManager()

	{

	}

void CTestManager::ConstructL()

	{

	iTestLibrary = CCalTestLibrary::NewL();

	test.Printf(_L("Make sure the file is deleted when we start the test"));

	TRAP_IGNORE(iTestLibrary->GetSession().DeleteCalFileL(KCalendarFile));

	User::LeaveIfError(iAlarmServer.Connect());

	}

CTestManager::~CTestManager()

	{

	delete iTestLibrary;

	iAlarmServer.Close();

	}

void CTestManager::CleanupDeleteCalFile(TAny* aRef)

    {

    CCalSession* session = static_cast<CCalSession*>(aRef);

    TRAPD(error, session->DeleteCalFileL(KCalendarFile));

    if (error != KErrNone)

        {

        test.Printf(_L("There was a problem deleting the file! %d"), error);

        }

    delete session;

    }

void CTestManager::TestSetAndUpdatePropertyL()

    {

    test.Next(_L("Test setting some properties"));

    test.Printf(_L("create some meta data"));

    CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();

    CleanupStack::PushL(calendarInfo);

    test.Printf(_L("Add some properties to the metadata"));

    TTime now;

    now.HomeTime();

    TPckgC<TTime> timePckg1(now);

    calendarInfo->SetPropertyL(KPropertyTimeKey, timePckg1);

    TPckgC<TInt> intPckg1(KPropertyIntValue + 1);

    calendarInfo->SetPropertyL(KPropertyIntKey, intPckg1);

    calendarInfo->SetPropertyL(KPropertyStringKey, KPropertyStringValue);

    test.Printf(_L("Create a calendar file with the metadata"));

    iTestLibrary->GetSession().CreateCalFileL(KCalendarFile, *calendarInfo);

    test.Next(_L("Test updating some of the metadata properties"));

    TPckgC<TTime> timePckg2(KPropertyTimeValue);

    calendarInfo->SetPropertyL(KPropertyTimeKey, timePckg2);

    TPckgC<TTime> intPckg2(KPropertyIntValue);

    calendarInfo->SetPropertyL(KPropertyIntKey, intPckg2);

    test.Printf(_L("Open the file"));

    iTestLibrary->GetSession().OpenL(KCalendarFile);

    test.Printf(_L("Set the calendar info"));

    iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);

    CleanupStack::PopAndDestroy(calendarInfo);

    }

void CTestManager::TestGetPropertyL()

    {

    test.Next(_L("Test fetching the metadata"));

    // fetch the calendar info from the session

    CCalCalendarInfo* calendarInfo = iTestLibrary->GetSession().CalendarInfoL();

    CleanupStack::PushL(calendarInfo);

    test.Printf(_L("Fetch the property keys"));

    CDesC8Array* propertyKeys = calendarInfo->PropertyKeysL();

    CleanupStack::PushL(propertyKeys);

    test.Printf(_L("Test that there are only three properties"));

    test(propertyKeys->Count() == 3);

    test.Printf(_L("Test that all three property keys are found"));

    TInt pos(KErrNotFound);

    test(propertyKeys->Find(KPropertyTimeKey, pos, ECmpNormal) != KErrNotFound);

    test(propertyKeys->Find(KPropertyIntKey, pos, ECmpNormal) != KErrNotFound);

    test(propertyKeys->Find(KPropertyStringKey, pos, ECmpNormal) != KErrNotFound);

    CleanupStack::PopAndDestroy(propertyKeys);

    test.Printf(_L("Test that the time property is set to the correct value"));

    TTime time;

    TPckgC<TTime> timeBuf(time);

    timeBuf.Set(calendarInfo->PropertyValueL(KPropertyTimeKey));

    time = timeBuf();

    test(time == KPropertyTimeValue);

    test.Printf(_L("Test that the int property is set to the correct value"));

    TInt intVal;

    TPckgC<TInt> intBuf(intVal);

    intBuf.Set(calendarInfo->PropertyValueL(KPropertyIntKey));

    intVal = intBuf();

    test(intVal == KPropertyIntValue);

    test.Printf(_L("Test that the string property is set to the correct value"));

    test(calendarInfo->PropertyValueL(KPropertyStringKey).Compare(KPropertyStringValue) == 0);

    CleanupStack::PopAndDestroy(calendarInfo);

    }

void CTestManager::TestRemovePropertyL()

    {

    test.Next(_L("Test that we can remove a property from the properties"));

    test.Printf(_L("Fetch the calendar info"));

    CCalCalendarInfo* calendarInfo = iTestLibrary->GetSession().CalendarInfoL();

    CleanupStack::PushL(calendarInfo);

    test.Printf(_L("We should have 3 property keys before removing one"));

    CDesC8Array* array = calendarInfo->PropertyKeysL();

    test(array->Count() == 3);

    delete array;

    test.Printf(_L("Remove the property by key"));

    calendarInfo->RemovePropertyL(KPropertyTimeKey);

    test.Printf(_L("We should now have 2 properties after removing one"));

    array = calendarInfo->PropertyKeysL();

    test(array->Count() == 2);

    delete array;

    test.Printf(_L("Set the calendar info"));

    iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);

    CleanupStack::PopAndDestroy(calendarInfo);

    calendarInfo = iTestLibrary->GetSession().CalendarInfoL();

    CleanupStack::PushL(calendarInfo);

    test.Printf(_L("Test that there are now only two keys"));

    CDesC8Array* propertyKeys = calendarInfo->PropertyKeysL();

    CleanupStack::PushL(propertyKeys);

    test(propertyKeys->Count() == 2);

    test.Printf(_L("Test that the correct two property keys are found"));

    TInt pos(KErrNotFound);

    test(propertyKeys->Find(KPropertyIntKey, pos, ECmpNormal) != KErrNotFound);

    test(propertyKeys->Find(KPropertyStringKey, pos, ECmpNormal) != KErrNotFound);

    CleanupStack::PopAndDestroy(propertyKeys);

    CleanupStack::PopAndDestroy(calendarInfo);

    }

void CTestManager::TestReplaceMetadataL()

    {

    _LIT8(KDifferentKey, "different key");

    _LIT8(KDifferentValue, "different value");

    test.Next(_L("Test that we can replace the metadata"));

    test.Printf(_L("create some new metadata"));

    CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();

    CleanupStack::PushL(calendarInfo);

    test.Printf(_L("Add a property to the metadata"));

    calendarInfo->SetPropertyL(KDifferentKey, KDifferentValue);

    test.Printf(_L("set the metadata"));

    iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);

    CleanupStack::PopAndDestroy(calendarInfo);

    test.Printf(_L("fetch the metadata"));

    calendarInfo = iTestLibrary->GetSession().CalendarInfoL();

    CleanupStack::PushL(calendarInfo);

    test.Printf(_L("Test that there is only the one new key"));

    CDesC8Array* propertyKeys = calendarInfo->PropertyKeysL();

    CleanupStack::PushL(propertyKeys);

    test(propertyKeys->Count() == 1);

    test.Printf(_L("Test that the correct two property keys are found"));

    TInt pos(KErrNotFound);

    test(propertyKeys->Find(KDifferentKey, pos, ECmpNormal) != KErrNotFound);

    CleanupStack::PopAndDestroy(propertyKeys);

    CleanupStack::PopAndDestroy(calendarInfo);

    }

/* 

@SYMTestCaseID				PIM-TCAL-CALENDAR-INFO-0001

@SYMPreq					CR1985

@SYMTestCaseDesc			Test that we can create a file with metadata.

@SYMTestPriority            1

@SYMTestType                CIT

@SYMTestStatus 				Implemented

@SYMTestActions 			1. Create a calendar info instance and set some values on it

							2. Create a file and specify that the calendar info is associated with it

@SYMTestExpectedResults		The calendar file should be created and the metadata set on it. 

**/

void CTestManager::TestCreateFileWithMetaDataL()

    {

    test.Next(_L("Test that a file can be created with meta data"));

    test.Printf(_L("Make sure the file is deleted when we start the test"));

    TRAP_IGNORE(iTestLibrary->GetSession().DeleteCalFileL(KCalendarFile));

    CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();

    CleanupStack::PushL(calendarInfo);

    test.Printf(_L("Set some properties on the meta data"));

    calendarInfo->SetNameL(KCalendarName);

    calendarInfo->SetDescriptionL(KCalendarDescription);

    calendarInfo->SetColor(KCalendarColor);

    calendarInfo->SetEnabled(KCalendarEnabled);

    test.Printf(_L("Use the create cal file overload method that takes calendar info"));

    iTestLibrary->GetSession().CreateCalFileL(KCalendarFile, *calendarInfo);

    CleanupStack::PopAndDestroy(calendarInfo);

    }

/* 

@SYMTestCaseID				PIM-TCAL-CALENDAR-INFO-0002

@SYMPreq					CR1985

@SYMTestCaseDesc			Test that we can set metadata on a file that already exists.

@SYMTestPriority            1

@SYMTestType                CIT

@SYMTestStatus 				Implemented

@SYMTestActions 			1. Create a file without metadata

							2. Create a calendar info instance and set some values on it

							2. Set the calendar info is associated with it

@SYMTestExpectedResults		The calendar file should be created and the metadata set on it. 

**/

void CTestManager::TestSetMetaDataL()

    {

    test.Next(_L("Test that you can set meta data on a file that already exists"));

    test.Printf(_L("Make sure the file is deleted when we start the test"));

    TRAP_IGNORE(iTestLibrary->GetSession().DeleteCalFileL(KCalendarFile));

    test.Printf(_L("Create the cal file without meta data"));

    iTestLibrary->GetSession().CreateCalFileL(KCalendarFile);

    test.Printf(_L("open the file"));

    iTestLibrary->GetSession().OpenL(KCalendarFile);

    iTestLibrary->GetSession().FileIdL(iFileId);

    test.Printf(_L("create the meta data object"));

    CCalCalendarInfo* calendarInfo = CCalCalendarInfo::NewL();

    CleanupStack::PushL(calendarInfo);

    test.Printf(_L("Set some properties on the meta data"));

    calendarInfo->SetNameL(KCalendarName);

    calendarInfo->SetDescriptionL(KCalendarDescription);

    calendarInfo->SetColor(KCalendarColor);

    calendarInfo->SetEnabled(KCalendarEnabled);

    test.Printf(_L("Set the meta data on the file"));

    iTestLibrary->GetSession().SetCalendarInfoL(*calendarInfo);

    CleanupStack::PopAndDestroy(calendarInfo);

    }

/* 

@SYMTestCaseID				PIM-TCAL-CALENDAR-INFO-0003

@SYMPreq					CR1985

@SYMTestCaseDesc			Test that we are able to fetch metadata that has been set on a file.

@SYMTestPriority            1

@SYMTestType                CIT

@SYMTestStatus 				Implemented

@SYMTestActions 			1. Open a file with metadata

							2. fetch the properties of the metadata

@SYMTestExpectedResults		The metadata should be there and the properties should have the correct values.

**/

void CTestManager::TestGetMetaDataL()

    {

    test.Next(_L("Test that you can set meta data on a file that already exists"));

    test.Printf(_L("open the file"));

    iTestLibrary->GetSession().OpenL(KCalendarFile);

    iTestLibrary->GetSession().FileIdL(iFileId);

    test.Printf(_L("get the meta data"));

    CCalCalendarInfo* calendarInfo = iTestLibrary->GetSession().CalendarInfoL();

    if (calendarInfo)

        {

        test.Printf(_L("There is meta data so test that is set correctly"));

        CleanupStack::PushL(calendarInfo);

        test(calendarInfo->FileNameL().Compare(KCalendarFileExpected) == 0);

        test(calendarInfo->NameL().Compare(KCalendarName) == 0);

        test(calendarInfo->DescriptionL().Compare(KCalendarDescription) == 0);

        test(calendarInfo->Color() == KCalendarColor);

        test(calendarInfo->Enabled() == KCalendarEnabled);

        CleanupStack::PopAndDestroy(calendarInfo);

        }

    else

        {

        test.Printf(_L("There is no meta data"));

        test(EFalse);

        }

    }

/* 

@SYMTestCaseID				PIM-TCAL-CALENDAR-INFO-0004

@SYMPreq					CR1985

@SYMTestCaseDesc			Test that we can fetch metadata for all files through the calendar iterator.

@SYMTestPriority            1

@SYMTestType                CIT

@SYMTestStatus 				Implemented

@SYMTestActions 			1. Have 1 file that has metadata set on it

							2. Have many other files that do not have metadata (calendar files from other tests). 

							3. Create a calendar iterator

							4. iterate through all calendars fetching metadata of it exitsts

@SYMTestExpectedResults		Only one file should have valid metadata and it should have the correct values.

**/

void CTestManager::TestGetAllMetaDataL()

    {

    test.Next(_L("Test iterating through all meta data set on the calendar server"));

    test.Printf(_L("create the iterator"));

    CCalCalendarIterator* calendarIterator = CCalCalendarIterator::NewL(iTestLibrary->GetSession());

    CleanupStack::PushL(calendarIterator);

    CDesCArray* calFiles = iTestLibrary->GetSession().ListCalFilesL();

    CleanupStack::PushL(calFiles);

    test.Printf(_L("Test the meta data count is the same as the list calendar info count"));

    const TInt KCalendarInfoCount = calendarIterator->Count();

    const TInt KListFilesCount = calFiles->Count();

    test(KCalendarInfoCount == KListFilesCount);

    test.Printf(_L("Iterate through the calendar info collection"));

    TInt validCount(0);

    TInt totalCount(0);

    for (CCalCalendarInfo* calendarInfo = calendarIterator->FirstL();

            calendarInfo != NULL ;

            calendarInfo = calendarIterator->NextL())

        {

        CleanupStack::PushL(calendarInfo);

        test.Printf(_L("File %d = %S\n"), ++totalCount, &calendarInfo->FileNameL());

        if (calendarInfo->IsValid())

            {

            test.Printf(_L("The file is valid so test that the properties are as expected"));

            ++validCount;

            test(calendarInfo->FileNameL().Compare(KCalendarFileExpected) == 0);

            test(calendarInfo->NameL().Compare(KCalendarName) == 0);

            test(calendarInfo->DescriptionL().Compare(KCalendarDescription) == 0);

            test(calendarInfo->Color() == KCalendarColor);

            test(calendarInfo->Enabled() == KCalendarEnabled);

            }

        else

            {

            test.Printf(_L("The file is invalid, but make sure it is one of the files from ListCalFilesL"));

            TInt pos(KErrNotFound);

            TInt findError = calFiles->Find(calendarInfo->FileNameL(), pos);

            test(findError == KErrNone);

            // Remove the file from the list so that we test we don't get duplicates

            calFiles->Delete(pos);

            }

        test.Printf(_L("Test that the CurrentL API works"));

        CCalCalendarInfo* currentCalendarInfo = calendarIterator->CurrentL();

        CleanupStack::PushL(currentCalendarInfo);

        test(currentCalendarInfo->IsValid() == calendarInfo->IsValid());

        test(currentCalendarInfo->FileNameL().Compare(calendarInfo->FileNameL()) == 0 );

        if (currentCalendarInfo->IsValid())

            {

            test.Printf(_L("The info is valid so test that all the other properties are the same"));

            test(calendarInfo->FileNameL().Compare(KCalendarFileExpected) == 0);

            test(calendarInfo->NameL().Compare(KCalendarName) == 0);

            test(calendarInfo->DescriptionL().Compare(KCalendarDescription) == 0);

            test(calendarInfo->Color() == KCalendarColor);

            test(calendarInfo->Enabled() == KCalendarEnabled);

            }

        CleanupStack::PopAndDestroy(currentCalendarInfo);

        CleanupStack::PopAndDestroy(calendarInfo);

        }

    test.Printf(_L("Test that we only found one file with valid meta data"));

    test(validCount == 1);

    CleanupStack::PopAndDestroy(calFiles);

    CleanupStack::PopAndDestroy(calendarIterator);

    }

/* 

@SYMTestCaseID				PIM-TCAL-CALENDAR-INFO-0005

@SYMPreq					CR1985

@SYMTestCaseDesc			Test that all the metadata APIs work under OOM conditions.

@SYMTestPriority            1