// Copyright (c) 1997-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 <e32test.h>
#include <caluser.h>
#include <calsession.h>
#include <calentry.h>

static RTest test(_L("tcal_attendee"));

_LIT8(KGUID1, "A_Global_UID1");
_LIT8(KGUID2, "A_Global_UID2");
_LIT8(KGUID3, "A_Global_UID3");
_LIT(KCalName, "TestCalendar");

_LIT(KAttendee1Address, "attendee.one@example.com");
_LIT(KAttendee2Address, "attendee.two@example.com");
_LIT(KAttendee3Address, "attendee.three@example.com");
_LIT(KAttendee4Address, "attendee.four@example.com");
_LIT(KAttendee2SentBy, "sent.by@example.com");
_LIT(KAttendee1CommonName, "attendee1");
_LIT(KAttendee3CommonNameA, "attendee3a");
_LIT(KAttendee3CommonNameB, "attendee3b");
_LIT(KOrganizerCommonName, "example_organizer");
_LIT(KOrganizerSentByA, "organizer.sentby@example.com");
_LIT(KOrganizerAddressA, "organizer.a@example.com");
_LIT(KOrganizerAddressB, "organizer.b@example.com");
_LIT(KAttendee11Address, "attendee.representative@example.com");
_LIT(KAttendee12Address, "attendee.twelve@example.com");
_LIT(KAttendee13Address, "attendee.thirteen@example.com");
_LIT(KAttendee14Address, "attendee.fourteen@example.com");
_LIT(KAttendee12SentBy,  "attendee.sentby@example.com");
_LIT(KOrganizerCommonName1, "another_organizer");


class CAttendeeTestManager : public CBase
	{
public:
    static CAttendeeTestManager* NewLC();
	~CAttendeeTestManager();	
	void CreateAndPopulateEntryL();
	void TestOrganizerL();
	void TestAttendeesL();
	void TestPhoneOwnerL();
	CCalEntry* Entry();
	void CompareEntriesL();
	void TestCopyFromL();
private:
	void ConstructL();
	void PrintAttendeeL(CCalAttendee* aAttendee);	
	void TestStatusValuesL(CCalAttendee* aAttendee);
	void TestRoleValuesL(CCalAttendee* aAttendee);
private:
	CCalTestLibrary* iTestLib;
	CCalEntry* iEntry;
	TCalTime iCalTime1;
	TCalTime iCalTime2;
	};


CAttendeeTestManager* CAttendeeTestManager::NewLC()
	{
	CAttendeeTestManager* self = new (ELeave) CAttendeeTestManager();
	
	CleanupStack::PushL(self);
	self->ConstructL();
	
	return (self);
	}

	
void CAttendeeTestManager::ConstructL()
	{
	iTestLib = CCalTestLibrary::NewL();
	iTestLib->ReplaceFileL(KCalName);
	iTestLib->OpenFileL(KCalName);	
	}	

	
CAttendeeTestManager::~CAttendeeTestManager()	
	{
	delete iTestLib;
	delete iEntry;
	}


void CAttendeeTestManager::PrintAttendeeL(CCalAttendee* aAttendee)
	{
	TPtrC ptrAddress(aAttendee->Address());
	TPtrC ptrSentBy(aAttendee->SentBy());
	TPtrC ptrCommonName(aAttendee->CommonName());
	TInt status = aAttendee->StatusL();
	TInt role = aAttendee->RoleL();
	TBool rsvp = aAttendee->ResponseRequested();		
		
	test.Printf(_L("~~:ATTENDEE DETAILS:~~\n"));
	test.Printf(_L("Address:\t%S\n"), &ptrAddress);
	test.Printf(_L("Sent-By:\t%S\n"), &ptrSentBy);
	test.Printf(_L("Common Name:\t%S\n"), &ptrCommonName);
	test.Printf(_L("RSVP:\t%d\n"), rsvp);
	test.Printf(_L("CalStatus:\t%d\n"), status);
	test.Printf(_L("CalRole:\t%d\n"), role);
	}


void CAttendeeTestManager::TestRoleValuesL(CCalAttendee* aAttendee)
	{
	test.Next(_L("Testing Role Values"));

	aAttendee->SetRoleL(CCalAttendee::ENonParticipant); 
	test((aAttendee->RoleL() == CCalAttendee::ENonParticipant));		
	aAttendee->SetRoleL(CCalAttendee::EReqParticipant); 
	test((aAttendee->RoleL() == CCalAttendee::EReqParticipant));			
	aAttendee->SetRoleL(CCalAttendee::EOptParticipant); 
	test((aAttendee->RoleL() == CCalAttendee::EOptParticipant));			
	aAttendee->SetRoleL(CCalAttendee::EChair); 
	test((aAttendee->RoleL() == CCalAttendee::EChair));		
	}

		

void CAttendeeTestManager::TestStatusValuesL(CCalAttendee* aAttendee)
	{
	test.Next(_L("Testing Status Values"));

	aAttendee->SetStatusL(CCalAttendee::EInProcess);
	test((aAttendee->StatusL() == CCalAttendee::EInProcess));		
	aAttendee->SetStatusL(CCalAttendee::ENeedsAction);
	test((aAttendee->StatusL() == CCalAttendee::ENeedsAction));	
	aAttendee->SetStatusL(CCalAttendee::EAccepted);
	test((aAttendee->StatusL() == CCalAttendee::EAccepted));	
	aAttendee->SetStatusL(CCalAttendee::ETentative);
	test((aAttendee->StatusL() == CCalAttendee::ETentative));	
	aAttendee->SetStatusL(CCalAttendee::EConfirmed);
	test((aAttendee->StatusL() == CCalAttendee::EConfirmed));	
	aAttendee->SetStatusL(CCalAttendee::EDeclined);
	test((aAttendee->StatusL() == CCalAttendee::EDeclined));
	aAttendee->SetStatusL(CCalAttendee::ECompleted);
	test((aAttendee->StatusL() == CCalAttendee::ECompleted));	
	aAttendee->SetStatusL(CCalAttendee::EDelegated);
	test((aAttendee->StatusL() == CCalAttendee::EDelegated));	
	}


void CAttendeeTestManager::CreateAndPopulateEntryL()
	{
	//	set up entry
	TTime time1;
	time1.HomeTime();
	TTime time2(time1);
	time2 += TTimeIntervalMonths(30);	
	
	HBufC8* guid = KGUID1().AllocLC();

	iEntry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);
	CleanupStack::Pop(guid);
	
	
	iCalTime1.SetTimeUtcL(time1);
	iCalTime2.SetTimeUtcL(time2);
	iEntry->SetStartAndEndTimeL(iCalTime1, iCalTime2);
	
	test.Next(_L("Create and add a list of attendees to an entry"));


	CCalAttendee* attendee1 = CCalAttendee::NewL(KAttendee1Address);
	CleanupStack::PushL(attendee1);
	
	iEntry->AddAttendeeL(attendee1);	
	CleanupStack::Pop(attendee1);
	
	test.Printf(attendee1->SentBy());
	test.Printf(_L("\n"));
	test(attendee1->SentBy() == KNullDesC);

	CCalAttendee* attendee2 = CCalAttendee::NewL(KAttendee2Address, KAttendee2SentBy);
	iEntry->AddAttendeeL(attendee2);	
	test(attendee2->SentBy() != KNullDesC);

	CCalAttendee* attendee3 = CCalAttendee::NewL(KAttendee3Address);
	iEntry->AddAttendeeL(attendee3);	
	test.Printf(attendee3->SentBy());
	test.Printf(_L("\n"));

	CCalAttendee* attendee4 = CCalAttendee::NewL(KAttendee4Address);
	CleanupStack::PushL(attendee4);
	attendee4->SetResponseRequested(ETrue);
	test(attendee4->ResponseRequested());
	CleanupStack::Pop(attendee4);	
	iEntry->AddAttendeeL(attendee4);	
	
	test(iEntry->AttendeesL().Count() == 4);
	}


void CAttendeeTestManager::TestOrganizerL()
	{
	test.Next(_L("Testing that an organizer can be created and added to an entry."));

	
	CCalUser* organiserA = CCalUser::NewL(KOrganizerAddressA, KOrganizerSentByA);
	iEntry->SetOrganizerL(organiserA);
	
	CCalUser* organiserB = CCalUser::NewL(KOrganizerAddressB);
	CleanupStack::PushL(organiserB);
	
	test(organiserA->SentBy() != KNullDesC);
	test(iEntry->OrganizerL()->SentBy() == KOrganizerSentByA);
	test(organiserB->SentBy() == KNullDesC);
	organiserB->SetCommonNameL(KOrganizerCommonName);	
	CleanupStack::Pop(organiserB);
	iEntry->SetOrganizerL(organiserB);
	
	CCalUser* organiser = NULL;
	organiser = iEntry->OrganizerL();
	
	TPtrC ptrAddress(organiser->Address());
	TPtrC ptrSentBy(organiser->SentBy());
	TPtrC ptrCommonName(organiser->CommonName());

	test(organiser->Address() == KOrganizerAddressB);
	test(organiser->SentBy() == KNullDesC);
	test(organiser->CommonName() == KOrganizerCommonName);
	
	test.Printf(_L("ORGANISER details:"));
	test.Printf(_L("Address:\t%S\n"), &ptrAddress);
	test.Printf(_L("Sent-By:\t%S\n"), &ptrSentBy);
	test.Printf(_L("Common Name:\t%S\n"), &ptrCommonName);	
	}


void CAttendeeTestManager::TestAttendeesL()
	{
	RPointerArray<CCalAttendee> attendeeList = iEntry->AttendeesL();
	CleanupClosePushL(attendeeList);

	TInt count = attendeeList.Count();

	test.Printf(_L("Printing All Attendees before changes\n"));
	
	for(TInt i=0 ; i < count; ++i)
		{
		PrintAttendeeL(attendeeList[i]);
		}		
	
	test.Printf(_L("Setting common names\n"));
	attendeeList[0]->SetCommonNameL(KAttendee1CommonName);
	test(attendeeList[0]->CommonName() == KAttendee1CommonName);
	attendeeList[2]->SetCommonNameL(KAttendee3CommonNameA);
	test(attendeeList[2]->CommonName() == KAttendee3CommonNameA);
	attendeeList[2]->SetCommonNameL(KAttendee3CommonNameB); // checking that you can change common name once set
	test(attendeeList[2]->CommonName() == KAttendee3CommonNameB);	
		
	//	testing the setting of status/role values
	TestRoleValuesL(attendeeList[1]);
	TestStatusValuesL(attendeeList[3]);

	//	testing invalid role and status values
	TInt fakeEnumValue = 20;
	CCalAttendee::TCalRole fakeRole;
	CCalAttendee::TCalStatus fakeStatus;
	
	fakeRole = static_cast<CCalAttendee::TCalRole>(fakeEnumValue);
	fakeStatus = static_cast<CCalAttendee::TCalStatus>(fakeEnumValue);
	
	TRAPD(err, attendeeList[1]->SetRoleL(fakeRole));
	test(err == KErrNotFound);
	err = 0;
	TRAP(err, attendeeList[1]->SetStatusL(fakeStatus));		
	test(err == KErrNotFound);
	
	CleanupStack::Pop(&attendeeList);
	}


void CAttendeeTestManager::TestPhoneOwnerL()
	{
	RPointerArray<CCalAttendee> attendeeList = iEntry->AttendeesL();
	CleanupClosePushL(attendeeList);
	
	iEntry->SetPhoneOwnerL(iEntry->OrganizerL());
	test.Printf(_L("Testing phone owner is example organizer\n"));
	PrintAttendeeL(static_cast<CCalAttendee*>(iEntry->PhoneOwnerL()));
	test(iEntry->PhoneOwnerL()->CommonName() == KOrganizerCommonName);
	test(iEntry->PhoneOwnerL()->Address() == KOrganizerAddressB);
	
	
	iEntry->SetPhoneOwnerL(attendeeList[2]);
	test.Printf(_L("Testing phone owner is attendee three\n"));
	PrintAttendeeL(static_cast<CCalAttendee*>(iEntry->PhoneOwnerL()));
	test(iEntry->PhoneOwnerL()->Address() == KAttendee3Address);
	test(iEntry->PhoneOwnerL()->CommonName() == KAttendee3CommonNameB);

	attendeeList[2]->SetCommonNameL(_L("A random common name"));
	PrintAttendeeL(static_cast<CCalAttendee*>(iEntry->PhoneOwnerL()));
	test(iEntry->PhoneOwnerL()->CommonName() == _L("A random common name"));
	
	//	delete the attendee that is set as the phone owner
	iEntry->DeleteAttendeeL(2);
	
	if(iEntry->PhoneOwnerL())
		{
		test.Printf(_L("Phone owner deleted so it should not come in here!\n"));
		PrintAttendeeL(static_cast<CCalAttendee*>(iEntry->PhoneOwnerL()));
		test(0);	// panic
		}
	else
		{
		test.Printf(_L("Phone Owner No longer exists!\n"));
		}
	test.Printf(_L("ensuring organizer NICK HANLING is still there\n"));
	PrintAttendeeL(static_cast<CCalAttendee*>(iEntry->OrganizerL()));

	test.Printf(_L("Cleaning up the objects and finishing test!\n"));
	
	CleanupStack::Pop(&attendeeList);
	}


//Test code added for Defect DEF063673

void CAttendeeTestManager::CompareEntriesL()
	{
	test.Next(_L("Compare two entries"));

	
	//	set up entry
	HBufC8* guid = KGUID2().AllocLC();
	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);
	CleanupStack::Pop(guid);
	CleanupStack::PushL(entry);
	
	entry->SetStartAndEndTimeL(iCalTime1, iCalTime2);
	
	test.Printf(_L("Create a list of Attendees and an Organiser\n"));
	

	CCalAttendee* attendee1 = CCalAttendee::NewL(KAttendee11Address);
	CleanupStack::PushL(attendee1);
	entry->AddAttendeeL(attendee1);	
	CleanupStack::Pop(attendee1);
	
	CCalAttendee* attendee2 = CCalAttendee::NewL(KAttendee12Address, KAttendee12SentBy);
	CleanupStack::PushL(attendee2);
	entry->AddAttendeeL(attendee2);	
	CleanupStack::Pop(attendee2);

	CCalAttendee* attendee3 = CCalAttendee::NewL(KAttendee13Address);
	CleanupStack::PushL(attendee3);	
	entry->AddAttendeeL(attendee3);	
	CleanupStack::Pop(attendee3);

	CCalAttendee* attendee4 = CCalAttendee::NewL(KAttendee14Address);
	CleanupStack::PushL(attendee4);
	attendee4->SetResponseRequested(ETrue);
	test(attendee4->ResponseRequested());
	entry->AddAttendeeL(attendee4);	
	CleanupStack::Pop(attendee4);
	
	
	CCalUser* organiser1 = CCalUser::NewL(_L("organizer.one@example.com"), _L("dummy"));
	CleanupStack::PushL(organiser1);
	entry->SetOrganizerL(organiser1);
	CleanupStack::Pop(organiser1);
	
	
	CCalUser* organiser = CCalUser::NewL(_L("another.organizer@example.com"));
	CleanupStack::PushL(organiser);
	organiser->SetCommonNameL(KOrganizerCommonName1);	
	entry->SetOrganizerL(organiser);
	CleanupStack::Pop(organiser);

	organiser = NULL;
	organiser = entry->OrganizerL();
	
	TPtrC ptrAddress(organiser->Address());
	TPtrC ptrSentBy(organiser->SentBy());
	TPtrC ptrCommonName(organiser->CommonName());
	
	TRAPD(ret,entry->CompareL(*iEntry));
	test.Printf(_L("Return value from CCalEntry::CompareL function comparing two entries:%d\n"),ret);
	test(ret == KErrNone);
	
	CleanupStack::PopAndDestroy(entry);
	
	test.Printf(_L("End of comparing two entries\n"));
	}
	

// Test code added for Defect DEF077508

void CAttendeeTestManager::TestCopyFromL()
	{
	
	// Create a new entry, then use CopyFromL to copy data from this class's iEntry
	test.Next(_L("TestCopyFromL"));


	HBufC8* guid = KGUID3().AllocLC();
	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);
	CleanupStack::Pop(guid);
	CleanupStack::PushL(entry);
	
	entry->SetStartAndEndTimeL(iCalTime1, iCalTime2);
	
	CCalAttendee* attendee1 = CCalAttendee::NewL(KAttendee11Address);
	CleanupStack::PushL(attendee1);
	entry->AddAttendeeL(attendee1);	
	CleanupStack::Pop(attendee1);
	
	CCalAttendee* attendee2 = CCalAttendee::NewL(KAttendee12Address, KAttendee12SentBy);
	CleanupStack::PushL(attendee2);
	entry->AddAttendeeL(attendee2);	
	CleanupStack::Pop(attendee2);
	
	CCalUser* organiser1 = CCalUser::NewL(_L("some.dude@example.com"), _L("me"));
	CleanupStack::PushL(organiser1);
	entry->SetOrganizerL(organiser1);
	CleanupStack::Pop(organiser1);
	
	entry->CopyFromL(*iEntry);	
	test(entry->AttendeesL().Count() == iEntry->AttendeesL().Count());

	CleanupStack::PopAndDestroy(entry);
	test.Printf(_L("End of TestCopyFromL\n"));
	}


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * DoTestL()
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	
static void DoTestL()
	{
	CAttendeeTestManager* testManager = CAttendeeTestManager::NewLC();
	

	TPerformanceTimer timer(test);
	timer.Start();	


	// Run the test suite

	testManager->CreateAndPopulateEntryL();
	testManager->TestOrganizerL();
	testManager->CompareEntriesL();
	testManager->TestAttendeesL();
	testManager->TestPhoneOwnerL();
	testManager->TestCopyFromL();
	
	
	timer.Stop();
	test.Printf(_L("Done\n"));
	// printout performance time
	timer.PrintOut();


	CleanupStack::PopAndDestroy(testManager);
	}


/**

@SYMTestCaseID     PIM-TCAL-ATTENDEE-0001

*/

TInt E32Main()
    {
	__UHEAP_MARK;

	test.Start(_L("@SYMTESTCaseID:PIM-TCAL-ATTENDEE-0001 Calendar Interim API Attendee test suite"));

	test.Title();

	CTrapCleanup* trapCleanup = CTrapCleanup::New();
	if (!trapCleanup)
		{
		return KErrNoMemory;
		}

	CActiveScheduler* scheduler = new CActiveScheduler();
	if (!scheduler)
		{
		delete trapCleanup;
		return KErrNoMemory;
		}
	CActiveScheduler::Install(scheduler);	

	TRAPD(ret, DoTestL());
	test(ret == KErrNone);
	
	delete scheduler;
	delete trapCleanup;	

	test.End();
	test.Close();

	__UHEAP_MARKEND;

	return (KErrNone);
    }