// 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 <calnotification.h>

#include <calentryview.h>

#include <calsession.h>

#include <calprogresscallback.h>

#include <e32test.h>

#include <e32property.h>

LOCAL_D RTest test(_L("tcal_pubsubnotification"));

_LIT(KCalendarFileName, "c:TCal_PubSubNotification");

class CPubSubObserver : public CActive

	{

public:

	static CPubSubObserver* NewL(TInt aWatchValue);

	~CPubSubObserver();

	void Start();

	TBool WasCalled() const;

	TCalPubSubData GetDataL() const;

	// from CActive

	void RunL();

	void DoCancel();

private:

	// avoid any method but NewL instancing the class

	CPubSubObserver();

	// no copy constructor and assignment operator

	CPubSubObserver(CPubSubObserver& );

	CPubSubObserver& operator = (const CPubSubObserver& );	

	void ConstructL(TInt aWatchValue);

private:

	RProperty iProperty;

	TBool iWasCalled;

	TInt iWatchValue;

	};

CPubSubObserver* CPubSubObserver::NewL(TInt aWatchValue)

	{

	CPubSubObserver* self = new (ELeave) CPubSubObserver;

	CleanupStack::PushL(self);

	self->ConstructL(aWatchValue);

	CleanupStack::Pop(self);

	return (self);

	}

CPubSubObserver::CPubSubObserver() : CActive(EPriorityLow)

	{

	CActiveScheduler::Add(this);

	}

CPubSubObserver::~CPubSubObserver()

	{

	Cancel();

	}

void CPubSubObserver::ConstructL(TInt aWatchValue)

	{

	iWatchValue = aWatchValue;

	User::LeaveIfError(iProperty.Attach(KCalPubSubCategory, aWatchValue));

	}

void CPubSubObserver::Start()

	{

	if (!IsActive())

		{

		iProperty.Subscribe(iStatus);

		SetActive();

		}

	iWasCalled = EFalse;

	}

void CPubSubObserver::RunL()

	{

	iWasCalled = ETrue;

	test.Printf(_L("Got publish and subscribe callback\n"));

	CActiveScheduler::Stop();

	}

void CPubSubObserver::DoCancel()

	{

	iProperty.Cancel();

	}

TBool CPubSubObserver::WasCalled() const

	{

	return iWasCalled;

	}

TCalPubSubData CPubSubObserver::GetDataL() const

	{

	TPckgBuf<TCalPubSubData> psBuf;

	User::LeaveIfError(iProperty.Get(KCalPubSubCategory, iWatchValue, psBuf));

	return psBuf();

	}

//

class CPubSubNotificationTestManager : public CBase

	{

public:

	static CPubSubNotificationTestManager* NewLC();

	~CPubSubNotificationTestManager();

	void OpenFileL();

	void TestNegativeL();

	void TestStoreLotEntriesL();

	void TestTodosL();

	void TestAppointmentsL();

	void TestRemindersL();

	void TestEventsL();

	void TestAnniversariesL();

private:

	// avoid any method but NewL instancing the class

	CPubSubNotificationTestManager() { }

	// no copy constructor and assignment operator

	CPubSubNotificationTestManager(CPubSubNotificationTestManager& );

	CPubSubNotificationTestManager& operator = (const CPubSubNotificationTestManager& );	

	void ConstructL();

	void RunTestL(CPubSubObserver* aObserver, CCalEntry::TType aType);

	void CheckThisObserverFired(CPubSubObserver* aObserver);

	void CheckNoObserversFiredL();	

	void CheckPSDataL(CPubSubObserver* aObserver);

	void PrepareForTest();

private:

	CCalTestLibrary* iTestLib;

	CPubSubObserver* iPubSubTodoObserver;

	CPubSubObserver* iPubSubEventObserver;

	TTime            iTestStartTime;

	};

// Constructor/Destructor

CPubSubNotificationTestManager* CPubSubNotificationTestManager::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

	}

void CPubSubNotificationTestManager::ConstructL()

	{

	iTestLib = CCalTestLibrary::NewL();

	}

void CPubSubNotificationTestManager::OpenFileL()

	{

	test.Printf(_L("Opening calendar file...\n"));	

	iTestLib->ReplaceFileL(KCalendarFileName());

	iTestLib->OpenFileL(KCalendarFileName());

	iPubSubTodoObserver = CPubSubObserver::NewL(ECalPubSubTodoNotification);

	iPubSubEventObserver = CPubSubObserver::NewL(ECalPubSubEventNotification);

	}

CPubSubNotificationTestManager::~CPubSubNotificationTestManager()

	{

	delete iPubSubTodoObserver;

	delete iPubSubEventObserver;

	delete iTestLib;

	}

static	TInt CancelWait(TAny* )

	{

	CActiveScheduler::Stop();

	return KErrNone;

	}		

void CPubSubNotificationTestManager::CheckNoObserversFiredL()

	{		

	test.Printf(_L("Waiting for callback\n"));

	CPeriodic* cancelTimer = CPeriodic::NewL(EPriorityHigh);

	CleanupStack::PushL(cancelTimer);

	TTimeIntervalMicroSeconds32 cancelWait = 500000;

	cancelTimer->Start(cancelWait, cancelWait, TCallBack(CancelWait));

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(cancelTimer);

	test(!iPubSubTodoObserver->WasCalled());

	test(!iPubSubEventObserver->WasCalled());

	}

void CPubSubNotificationTestManager::CheckThisObserverFired(CPubSubObserver* aObserver)

	{

	test(aObserver == iPubSubTodoObserver || aObserver == iPubSubEventObserver);

	test.Printf(_L("Waiting for callback\n"));

	CActiveScheduler::Start();

	test(aObserver->WasCalled());

	if (aObserver == iPubSubTodoObserver)

		{

		test(!iPubSubEventObserver->WasCalled());

		}

	else

		{

		test(!iPubSubTodoObserver->WasCalled());

		}

	}

void CPubSubNotificationTestManager::CheckPSDataL(CPubSubObserver* aObserver)

	{

	TCalPubSubData psData = aObserver->GetDataL();

	TTimeIntervalSeconds seconds;

	psData.iTimeOfChangeUtc.SecondsFrom(iTestStartTime, seconds);

	// check notification happened within 2 seconds

	test(seconds.Int() >= 0);

	test(seconds.Int() < 2);

	TFileName* fileName = new(ELeave) TFileName;

	CleanupStack::PushL(fileName);

	iTestLib->GetSession().GetFileNameL(psData, *fileName);

	test(iTestLib->GetSession().IsFileNameL(psData, *fileName));

	test(iTestLib->GetSession().IsOpenedFileL(psData));

	test(fileName->CompareF(KCalendarFileName()) == 0);

	CleanupStack::PopAndDestroy(fileName);

	}

void CPubSubNotificationTestManager::PrepareForTest()

	{

	iPubSubTodoObserver->Start();

	iPubSubEventObserver->Start();

	iTestStartTime.UniversalTime();

	}

void CPubSubNotificationTestManager::RunTestL(CPubSubObserver* aObserver, CCalEntry::TType aType)

	{

	RPointerArray<CCalEntry> entriesToAdd;

	CleanupClosePushL(entriesToAdd);

	test.Printf(_L("Create new entry\n"));

	_LIT8(KUid, "DUMMY UID 1234567890");

	HBufC8* uid = KUid().AllocLC();	

	CCalEntry* entry = iTestLib->CreateCalEntryL(aType, uid);

	CleanupStack::Pop(uid);

	CleanupStack::PushL(entry);

	CCalTestLibrary::SetEntryStartAndEndTimeL(entry);

	test.Printf(_L("Store entry\n"));

	PrepareForTest();

	CCalEntryView* entryView = &iTestLib->SynCGetEntryViewL();

	entriesToAdd.AppendL(entry);

	TInt success(0);

	entryView->StoreL(entriesToAdd, success);

	CheckThisObserverFired(aObserver);

	CheckPSDataL(aObserver);

	test.Printf(_L("Update entry\n"));

	PrepareForTest();

	entriesToAdd[0]->SetSummaryL(_L("dummy summary"));

	entryView->UpdateL(entriesToAdd, success);

	CheckThisObserverFired(aObserver);

	CheckPSDataL(aObserver);

	test.Printf(_L("Delete entry asynchronously\n"));

	PrepareForTest();

	TCalTime aStartTime;

	TCalTime aEndTime;

	aStartTime.SetTimeLocalL(TCalTime::MinTime());

	aEndTime.SetTimeLocalL(TCalTime::MaxTime());

	CalCommon::TCalTimeRange aTimeRange(aStartTime, aEndTime);

	entryView->DeleteL(aTimeRange, CalCommon::EIncludeAll, *iTestLib);

	// wait for delete operation to complete

	CActiveScheduler::Start();

	CheckThisObserverFired(aObserver);

	CheckPSDataL(aObserver);

	entriesToAdd.Reset();

	CleanupStack::PopAndDestroy(entry);

	uid = _L8("DUMMY UID 1234567890").AllocLC();

	entry = iTestLib->CreateCalEntryL(aType, uid);

	CleanupStack::Pop(uid);

	CleanupStack::PushL(entry);

	CCalTestLibrary::SetEntryStartAndEndTimeL(entry);

	iTestLib->GetSession().DisablePubSubNotificationsL();

	test.Printf(_L("Disable pub-sub test\n"));

	PrepareForTest();

	entriesToAdd.AppendL(entry);

	entryView->StoreL(entriesToAdd, success);	

	CheckNoObserversFiredL();

	iTestLib->GetSession().EnablePubSubNotificationsL();

	test.Printf(_L("Delete entry\n"));

	PrepareForTest();

	entryView->DeleteL(*entry);

	CheckThisObserverFired(aObserver);

	CheckPSDataL(aObserver);

	CleanupStack::PopAndDestroy(entry);

	CleanupStack::PopAndDestroy(); //entriesToAdd.Reset();	

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * Test cases forming the Pub Sub notification test suite

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

void CPubSubNotificationTestManager::TestTodosL()

	{

	test.Next(_L("Test Todos"));

	RunTestL(iPubSubTodoObserver,  CCalEntry::ETodo);

	}

void CPubSubNotificationTestManager::TestAppointmentsL()

	{

	test.Next(_L("Test Appointments"));

	RunTestL(iPubSubEventObserver, CCalEntry::EAppt);

	}

void CPubSubNotificationTestManager::TestRemindersL()

	{

	test.Next(_L("Test Reminders"));

	RunTestL(iPubSubEventObserver, CCalEntry::EReminder);

	}

void CPubSubNotificationTestManager::TestEventsL()

	{

	test.Next(_L("Test Events"));

	RunTestL(iPubSubEventObserver, CCalEntry::EEvent);

	}

void CPubSubNotificationTestManager::TestAnniversariesL()

	{

	test.Next(_L("Test Anniversaries"));

	RunTestL(iPubSubEventObserver, CCalEntry::EAnniv);

	}

void CPubSubNotificationTestManager::TestStoreLotEntriesL()

	{//Store more than 20 entries. It should have stoped the notifation before entries are stored and  but resumed after all entries are stored.

	//Add this test to ensure that it has not stoped the notication for the rest test cases.

	RPointerArray<CCalEntry> entries;

	CleanupResetAndDestroyPushL(entries);

	for(TInt ii=0;ii<30;++ii)

		{

		HBufC8* dummy = NULL;

		CCalEntry* entry = iTestLib->CreateCalEntryL(CCalEntry::EAppt, dummy);

		CleanupStack::PushL(entry);

		entries.AppendL(entry);

		CleanupStack::Pop(entry);

		CCalTestLibrary::SetEntryStartAndEndTimeL(entry);

		}

	TInt success;

	iTestLib->SynCGetEntryViewL().StoreL(entries, success);	

	CheckNoObserversFiredL();

	CleanupStack::PopAndDestroy(&entries);

	}

void CPubSubNotificationTestManager::TestNegativeL()

	{//Call those APIs without creating\opening a calendar file

	iTestLib->GetSession().DisablePubSubNotificationsL();

	iTestLib->GetSession().EnablePubSubNotificationsL();

	iTestLib->GetSession().DisableChangeBroadcast();

	iTestLib->GetSession().EnableChangeBroadcast();

	TCalFileId id;

	iTestLib->GetSession().FileIdL(id);

	test(id == 0);

	TCalPubSubData pubsub = { 0, 0 };

	TBuf<10> filename;

	TInt err;

	TRAP(err, iTestLib->GetSession().GetFileNameL(pubsub, filename));

	test(filename ==  KNullDesC());

	_LIT(KFileName,"abc");

	test( EFalse == iTestLib->GetSession().IsFileNameL(pubsub, KFileName));

	TRAP(err, iTestLib->GetSession().IsOpenedFileL(pubsub)); 

	test(err == KErrArgument);

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * DoTestL()

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

static void DoTestL()

	{

	CPubSubNotificationTestManager* testManager = CPubSubNotificationTestManager::NewLC();

	TPerformanceTimer timer(test);

	timer.Start();

	testManager->TestNegativeL();

	// Run the test suite

	testManager->OpenFileL();

	testManager->TestTodosL();

	testManager->TestAppointmentsL();

	testManager->TestRemindersL();

	testManager->TestEventsL();

	testManager->TestAnniversariesL();

	timer.Stop();

	test.Printf(_L("Done\n"));

	// printout performance time

	timer.PrintOut();

	CleanupStack::PopAndDestroy(testManager);

	}

/**

@SYMTestCaseID     PIM-TCAL-PUBSUBNOTIFICATION-0001

*/

TInt E32Main()

    {

	__UHEAP_MARK;

	test.Start(_L("@SYMTESTCaseID:PIM-TCAL-PUBSUBNOTIFICATION-0001 Calendar Interim API Publish and Subscribe 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);

    }