// Copyright (c) 2006-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 <calentry.h>

#include <calentryview.h>

#include <calalarm.h>

#include <calcategory.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <calrrule.h>

#include <caliterator.h>

#include <e32test.h>

#include <s32file.h>

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

class CCalOOMTest : public CBase

	{

public:

	static CCalOOMTest* NewLC();

 	void DoTestL();

	~CCalOOMTest();

private:

	void ConstructL();

	void CreateEntriesL();

	void TestFindInstancesL(const TDesC& aFindStartTime, const TDesC& aFindEndTime, CalCommon::TCalViewFilter aFilter);

private:

	CCalTestLibrary* iTestLib;

	};

_LIT(KCalName, "OOMDb");

void CCalOOMTest::CreateEntriesL()

	{

	_LIT8(KGuid1, "Reminder-1");

	_LIT8(KGuid2, "Appt-1");

	_LIT(KEntryStartTime, 		"20121119:013000.000000"); // 20-12-2012 01.30

	_LIT(KEntryEndTime, 		"20121119:090000.000000"); // 20-12-2012 09.00

	_LIT(KTimeUntil, 			"20131119:013000.000000"); // 20-12-2013 01.30

	_LIT(KSummary1, "THIS SUMMARY");

	_LIT(KSummary2, "Appt summary");

	//entry 1	

	HBufC8* guid8 = HBufC8::NewL(KGuid1().Length());

	guid8->Des().Copy(KGuid1);

	CleanupStack::PushL(guid8);

	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EReminder, guid8, CCalEntry::EMethodAdd, (TUint)0);	

	CleanupStack::Pop(guid8);

	entry->SetSummaryL(KSummary1);

	// entry2

	guid8 = HBufC8::NewL(KGuid2().Length());

	guid8->Des().Copy(KGuid2);

	CleanupStack::PushL(guid8);

	CCalEntry* entry2 = CCalEntry::NewL(CCalEntry::EAppt, guid8, CCalEntry::EMethodAdd, (TUint)0);	

	CleanupStack::Pop(guid8);

	entry2->SetSummaryL(KSummary2);

	TTime time1(KEntryStartTime());

	TTime time2(KEntryEndTime());

	TCalTime st;

	st.SetTimeUtcL(time1);

	TCalTime end;

	end.SetTimeUtcL(time2);

	entry->SetStartAndEndTimeL(st, end); 

	entry2->SetStartAndEndTimeL(st, end);

	TCalRRule* rRule=new (ELeave) TCalRRule(TCalRRule::EDaily);

	TCalTime calTime = entry->StartTimeL();

	rRule->SetDtStart(calTime);

	rRule->SetInterval(1);

	TTime until(KTimeUntil());

	TCalTime untilTime;

	untilTime.SetTimeUtcL(until);

	rRule->SetUntil(untilTime); 

	entry->SetRRuleL(*rRule);

	entry2->SetRRuleL(*rRule);

	TInt						entriesStored(0);

	RPointerArray<CCalEntry>	entriesToStore;

	CleanupResetAndDestroyPushL(entriesToStore);

	entriesToStore.AppendL(entry);

	entriesToStore.AppendL(entry2);

	iTestLib->SynCGetEntryViewL().StoreL(entriesToStore, entriesStored);

	delete rRule;

	CleanupStack::PopAndDestroy(&entriesToStore);

	// Find

	_LIT(KFindSt, 		"20131117:013000.000000"); // The event "overlaps" with this search range, hence must be caught. The reminder must not be caught (its end time = start time).

	_LIT(KFindEnd, 		"20131119:093000.000000");

	CalCommon::TCalViewFilter filter = CalCommon::EIncludeAll;

	TestFindInstancesL(KFindSt, KFindEnd, filter); // calling OOM test function

	}

void CCalOOMTest::TestFindInstancesL(const TDesC& aFindStartTime, const TDesC& aFindEndTime, CalCommon::TCalViewFilter aFilter)

	{

	test.Next(_L("OOM tests for FindInstanceL"));

	_LIT(KSearchText,				"summary");

	TCalTime findSt;

	findSt.SetTimeLocalL(TTime(aFindStartTime));

	TCalTime findEnd;

	findEnd.SetTimeLocalL(TTime(aFindEndTime));

	CalCommon::TCalTimeRange range(findSt, findEnd);

	RPointerArray<CCalInstance> instances;

	CCalInstanceView::TCalSearchParams params(KSearchText, CalCommon::EFoldedTextSearch);

	CCalInstanceView& view = iTestLib->SynCGetInstanceViewL();

	TInt tryCount = 1;

	TInt err = 0;

	// OOM LOOP

	for ( ;; )

		{

		RDebug::Printf("%d", tryCount);

		instances.ResetAndDestroy();

		__UHEAP_SETFAIL(RHeap::EFailNext, tryCount);

		__UHEAP_MARK;

		TRAP(err, view.FindInstanceL(instances, aFilter, range, params));

		if(	instances.Count()>0 )

		{

			instances.ResetAndDestroy();	//we are responsible for Cleanup of this array

		}

		__UHEAP_MARKEND;

		if ( err==KErrNone ) 

		{

			__UHEAP_RESET;

			RDebug::Printf("Memory allocation testing for FindInstance is done");

			break;

		}

		test(err == KErrNoMemory);

		__UHEAP_SETFAIL(RHeap::ENone, 0);		

		tryCount++;

		}

	// OOM LOOP

	}

void CCalOOMTest::DoTestL()

	{

		CreateEntriesL();

	}

CCalOOMTest* CCalOOMTest::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CCalOOMTest::ConstructL()

	{

	iTestLib = CCalTestLibrary::NewL();

	iTestLib->ReplaceFileL(KCalName());

	iTestLib->OpenFileL(KCalName());

	}

CCalOOMTest::~CCalOOMTest()

	{

	delete iTestLib;

	}

static void DoMainL()

	{

	CCalOOMTest* testApp = CCalOOMTest::NewLC();

	testApp->DoTestL();

	CleanupStack::PopAndDestroy(testApp);

	}

/**

@SYMTestCaseID     PIM-TCAL-OOMFIND-0001

*/

TInt E32Main()

    {

	__UHEAP_MARK;

	CTrapCleanup* trapCleanup = CTrapCleanup::New();

	CActiveScheduler* scheduler = new CActiveScheduler;

	test(scheduler != NULL);

	CActiveScheduler::Install(scheduler);

	test.Start(_L("@SYMTESTCaseID:PIM-TCAL-OOMFIND-0001 OOM tests for CalinterimAPI"));

	test.Title();

	TRAPD(r, DoMainL());

	test(r == KErrNone);

	test.End();

	test.Close();

	delete scheduler;

	delete trapCleanup;

	__UHEAP_MARKEND;

	return KErrNone;

    }