// 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 <calentryview.h>
#include <calinstance.h>
#include <calinstanceview.h>
#include <calrrule.h>
#include <e32test.h>
#include <s32file.h>
#include <vtzrules.h>

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

// Device time zone
_LIT8(KAmericaChicago, "America/Chicago");

class CCalTzInstanceTest : public CBase
	{
public:
	static CCalTzInstanceTest* NewLC();
 	void DoTestL();
    void DoCountYearlyByDayTestL();
    void DoUntilAfterDSTChangeTestL();
    void DoCountTestL();
	~CCalTzInstanceTest();

	void DoOOMTestTzClientCacheClearingL();
	void SupportCodeTestTzClientCacheClearingL();
private:
	void ConstructL();

private:
	CCalTestLibrary* iTestLib;
	};

_LIT(KCalName, "TestCalendarFile");

void CCalTzInstanceTest::DoCountYearlyByDayTestL()
    {
    iTestLib->CleanDatabaseL();
   
    TCalRRule rule(TCalRRule::EYearly);
   
    // create entry repeating on the second Tuesday on August for four instances, setting the Count
    TCalTime dtStart;
    dtStart.SetTimeLocalL(TDateTime(2006, EAugust, 0, 7, 0, 0, 0));
    rule.SetDtStart(dtStart);
   
    RArray<TMonth> months;
    CleanupClosePushL(months);
    months.AppendL(EAugust);
    rule.SetByMonth(months);
    CleanupStack::PopAndDestroy(&months);
   
    RArray<TCalRRule::TDayOfMonth> dayofmonths;
    CleanupClosePushL(dayofmonths);
    dayofmonths.AppendL(TCalRRule::TDayOfMonth(ETuesday, 2));
    rule.SetByDay(dayofmonths);
    CleanupStack::PopAndDestroy(&dayofmonths);
   
    rule.SetCount(4);
   
    HBufC8* guid = _L8("guid").AllocLC();
    CCalEntry* dummy = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);
    CleanupStack::Pop(guid);
    CleanupStack::PushL(dummy);
   
    dummy->SetStartAndEndTimeL(dtStart, dtStart);
    dummy->SetRRuleL(rule);
   
    TCalRRule rule2;
    dummy->GetRRuleL(rule2);
   
    TDateTime endDate = rule2.Until().TimeLocalL().DateTime();
   
    RPointerArray<CCalEntry> entryArray;
    CleanupClosePushL(entryArray);
    entryArray.AppendL(dummy);
    TInt success = 0;
    iTestLib->SynCGetEntryViewL().StoreL(entryArray, success);
    CleanupStack::PopAndDestroy(&entryArray);
   
    CleanupStack::PopAndDestroy(dummy);
   
    // Define the time range to find the instances
    TCalTime startTime;
    TCalTime endTime;
    startTime.SetTimeUtcL(TCalTime::MinTime());
    endTime.SetTimeUtcL(TCalTime::MaxTime());
   
    CalCommon::TCalTimeRange timeRange(startTime, endTime);
   
    RPointerArray<CCalInstance> instanceList;
   
    // Find all the instances within the specified time range
    iTestLib->SynCGetInstanceViewL().FindInstanceL(instanceList, CalCommon::EIncludeAll, timeRange);
   
    // Display all the instances found
    for (TInt instanceCounter = 0; instanceCounter < instanceList.Count(); ++instanceCounter)
        {
        TDateTime instanceDateTime = instanceList[instanceCounter]->StartTimeL().TimeUtcL().DateTime();
        RDebug::Print(_L("Found instance at %d:%d on %d/%d/%d"),
        instanceDateTime.Hour(), instanceDateTime.Minute(), instanceDateTime.Day()+1, instanceDateTime.Month()+1, instanceDateTime.Year());
        }

    // Verify the number of instances found
    test(instanceList.Count() == 4);
       
    instanceList.ResetAndDestroy();
    }

void CCalTzInstanceTest::DoUntilAfterDSTChangeTestL()
    {
    iTestLib->CleanDatabaseL();

	RPointerArray<CCalEntry> entries;
	
	CCalEntry* entry;
	HBufC8* uid;
	TCalTime startTime;
	TCalTime endTime;
	TCalTime untilTime;
	TCalRRule rrule;
	CTzRules* tzRules;
		
	// Allocate a UID.
	uid = HBufC8::NewL(50);
	uid->Des().Copy(_L8("{70706C03-015C-4550-BFAF-1B7067BF0141}"));
	
	// Symbian's day of month values are 0-based.
	startTime.SetTimeUtcL(TTime(TDateTime(2005, EMarch, 19, 19, 00, 0, 0))); 		
	endTime.SetTimeUtcL(TTime(TDateTime(2005, EMarch, 19, 19, 30, 0, 0)));			
	untilTime.SetTimeUtcL(TTime(TDateTime(2005, EApril, 9, 19, 00, 0, 0)));
	
	// Create the recurrence rule
	rrule.SetDtStart( startTime );
	rrule.SetInterval( 1 );
	rrule.SetUntil( untilTime );
	rrule.SetType( TCalRRule::EDaily );
	
	// Create time zone rules
	tzRules = CTzRules::NewL();
	tzRules->SetInitialStdTimeOffset( +420 );
	tzRules->SetStartYear( 0 );
	tzRules->SetEndYear( 9999 );
	// Arizona does not observe daylight savings time, so do not add any additional rules.

	// Setting current device Time Zone to USA/Chicago (Observers DST)
	//
	// USA, Chicago - UTC-6hrs Winter Time and UTC-5hrs Summer Time
	// DST starts on Sunday, 2 April 2005, 02:00 local standard time 
	// DST ends on Sunday, 29 October 2005, 02:00 local daylight time

	// Device Time Zone 
	iTestLib->SetTimeZoneL(KAmericaChicago);
				
	// Create the  entry.
	entry = CCalEntry::NewL( CCalEntry::EAppt, uid, CCalEntry::EMethodNone, 0 );
	
	entry->SetStartAndEndTimeL( startTime, endTime );
	
	entry->SetSummaryL( _L("Daily 3/20/2005 thru 4/10/2005 at 12:00pm") );
	
	// Set entry's repeat rule
	entry->SetRRuleL( rrule );
	
	// Set entry's repeat rule's time zone (different from the device time zone)
	entry->SetTzRulesL( *tzRules );
	
	delete tzRules;

	entries.Append( entry );
	
	// Store the recurring entry
	TInt successCount;
	TRAPD( err, iTestLib->SynCGetEntryViewL().StoreL( entries, successCount ) );
	
	// CHECKPOINT 1: Check that all the entries were successfully added (one entry)
	test(err == KErrNone && successCount == entries.Count());
	
	entries.ResetAndDestroy();
		
	// Define the time range to find the instances
	startTime.SetTimeUtcL(TCalTime::MinTime());
	endTime.SetTimeUtcL(TCalTime::MaxTime());
	
	CalCommon::TCalTimeRange timeRange(startTime, endTime);
	
	RPointerArray<CCalInstance> instanceList;
	
    // Find all the instances
    iTestLib->SynCGetInstanceViewL().FindInstanceL( instanceList, CalCommon::EIncludeAll, timeRange );
	
	// Display all the instances found
	for (TInt instanceCounter = 0; instanceCounter < instanceList.Count(); ++instanceCounter)
		{
		TDateTime instanceDateTime = instanceList[instanceCounter]->StartTimeL().TimeUtcL().DateTime();
		RDebug::Print(_L("Found instance at %d:%d on %d/%d/%d"),
		instanceDateTime.Hour(), instanceDateTime.Minute(), instanceDateTime.Day()+1, instanceDateTime.Month()+1, instanceDateTime.Year());
		}
	
	// Retrieve the last instance / last day for testing purposes
	CCalInstance* lastInstance = instanceList[instanceList.Count() - 1];
	
	TInt lastDay = lastInstance->StartTimeL().TimeUtcL().DateTime().Day();
	
	// CHECKPOINT 2: Check that the last day is valid
	test(lastDay == untilTime.TimeUtcL().DateTime().Day());

	instanceList.ResetAndDestroy();
	}

void CCalTzInstanceTest::DoCountTestL()
    {
    iTestLib->CleanDatabaseL();
   
    RPointerArray<CCalEntry> entries;
   
    // create entry with repeat rule set by the Count, then change the time zone and check end date is correct
    CCalEntry* entry;
    HBufC8* uid;
    TCalTime startTime;
    TCalTime endTime;
    TCalTime untilTime;
    TCalRRule rrule;
    CTzRules* tzRules;
       
    // Allocate a UID.
    uid = HBufC8::NewL(50);
    uid->Des().Copy(_L8("{70706C03-015C-4550-BFAF-1B7067BF0141}"));
   
    // Symbian's day of month values are 0-based.
    startTime.SetTimeUtcL(TTime(TDateTime(2005, EMarch, 19, 19, 00, 0, 0)));         
    endTime.SetTimeUtcL(TTime(TDateTime(2005, EMarch, 19, 19, 30, 0, 0)));           
   
    // Create the recurrence rule
    rrule.SetDtStart( startTime );
    rrule.SetInterval( 1 );
    rrule.SetCount( 22 );
    rrule.SetType( TCalRRule::EDaily );
   
    // Create time zone rules
    tzRules = CTzRules::NewL();
    tzRules->SetInitialStdTimeOffset( -420 );
    tzRules->SetStartYear( 0 );
    tzRules->SetEndYear( 9999 );

    // Create the  entry.
    entry = CCalEntry::NewL( CCalEntry::EAppt, uid, CCalEntry::EMethodNone, 0 );
   
    entry->SetStartAndEndTimeL( startTime, endTime );
   
    entry->SetSummaryL( _L("Daily 3/20/2005 thru 4/10/2005 at 12:00pm") );
   
    // Set entry's repeat rule
    entry->SetRRuleL( rrule );
   
    // Set entry's repeat rule's time zone (different from the device time zone)
    entry->SetTzRulesL( *tzRules );
   
    delete tzRules;

    entries.Append( entry );
   
    // Store the recurring entry
    TInt successCount;
    TRAPD( err, iTestLib->SynCGetEntryViewL().StoreL( entries, successCount ) );
   
    // CHECKPOINT 1: Check that all the entries were successfully added
    test(err == KErrNone && successCount == entries.Count());
   
    entries.ResetAndDestroy();
       
    // Define the time range to find the instances
    startTime.SetTimeUtcL(TCalTime::MinTime());
    endTime.SetTimeUtcL(TCalTime::MaxTime());
   
    CalCommon::TCalTimeRange timeRange(startTime, endTime);
   
    RPointerArray<CCalInstance> instanceList;
   
    // Find all the instances
    iTestLib->SynCGetInstanceViewL().FindInstanceL( instanceList, CalCommon::EIncludeAll, timeRange );
   
    // CHECKPOINT 2: Check all the instances are found
    test(instanceList.Count() == 22);

    instanceList.ResetAndDestroy();
    }

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

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


/**
 @SYMTestCaseID PIM-TCAL-TZ-INSTANCE-0002
 @SYMDEF DEF113539
 @SYMTestType UT
 @SYMTestPriority NORMAL
 @SYMDEF DEF113539
 @SYMTestCaseDesc Check if cache at Tz Client is cleared using the API ClearTzClientCacheL().
 
 @SYMTestActions
 1) Clean Tz Clientside cache before starting OOM test.
 2) Run OOM test.
 3) Clean Tz Clientside cache allocated inside OOM loop.
 4) Test if any memory allocated inside OOM loop has not been released.
 5) Clean Tz Clientside cache and RESTART caching.

 @SYMTestExpectedResults There should not be any memory leaks.
*/ 	

void CCalTzInstanceTest::DoOOMTestTzClientCacheClearingL()
	{
	test.Next(_L("@SYMTESTCaseID:PIM-TCAL-TZ-INSTANCE-0002 Testing Functionality for cleaning up Tz client cache."));

	
	TInt tryCount = 1;
	TInt err = 0;
	TBool cleanCache = EFalse;
	
	// OOM LOOP BEGINS
	for ( ;; )
		{
		iTestLib->__dbgClearTzClientCacheL(cleanCache);
		
		__UHEAP_SETFAIL(RHeap::EFailNext, tryCount);
		__UHEAP_MARK;
		TRAP(err, SupportCodeTestTzClientCacheClearingL());

		iTestLib->__dbgClearTzClientCacheL(cleanCache);
	
		if ( err==KErrNone ) 
			{
			__UHEAP_RESET;
			RDebug::Printf("OOM test for checking cleaning of Tz client cache compelete");
			break;
			}
		test(err == KErrNoMemory);
		__UHEAP_MARKEND;
		__UHEAP_SETFAIL(RHeap::ENone, 0);		
		++tryCount;
		}
	// OOM LOOP ENDS
	cleanCache = ETrue;
	iTestLib->__dbgClearTzClientCacheL(cleanCache); //RESTARTING CACHING
	}

/**
Support function for OOM test function DoOOMTestTzClientCacheClearingL.
Code attempts to convert different times so that Tz client cache keep variying.
*/
void CCalTzInstanceTest::SupportCodeTestTzClientCacheClearingL()
	{
	
	TTime gettime;
	TCalTime calStartTime;
	
	TTime recentTime(TDateTime(2005, EMay, 12, 9, 0, 0, 0)); 
	calStartTime.SetTimeUtcL(recentTime);
	
	TTime eighties(TDateTime(1985, EAugust, 12, 9, 0, 0, 0)); 
	calStartTime.SetTimeLocalL(eighties);
	gettime = calStartTime.TimeUtcL();
	
	TTime seventies(TDateTime(1975, EAugust, 12, 9, 0, 0, 0)); 
	calStartTime.SetTimeLocalL(seventies);
	gettime = calStartTime.TimeUtcL();
	
	TTime sixties(TDateTime(1965, EAugust, 12, 9, 0, 0, 0)); 
	calStartTime.SetTimeUtcL(sixties);
	gettime = calStartTime.TimeLocalL();
	
	}


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


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


	// Run the test suite
	
    testManager->DoCountYearlyByDayTestL();
    testManager->DoUntilAfterDSTChangeTestL();
    testManager->DoCountTestL();
	testManager->DoOOMTestTzClientCacheClearingL();

    
	timer.Stop();
	test.Printf(_L("Done\n"));
	// printout performance time
	timer.PrintOut();

    
	CleanupStack::PopAndDestroy(testManager);
	}
	

/**

@SYMTestCaseID     PIM-TCAL-TZ-INSTANCE-0001

*/

TInt E32Main()
    {
	__UHEAP_MARK;

	test.Start(_L("@SYMTESTCaseID:PIM-TCAL-TZ-INSTANCE-0001 Calendar Interim API Time Zone and Instance test suite"));

	test.Title();

	CTrapCleanup* trapCleanup = CTrapCleanup::New();
	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

	CActiveScheduler::Install(scheduler);	

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

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

	__UHEAP_MARKEND;

	return (KErrNone);
    }