diff -r 000000000000 -r f979ecb2b13e pimappservices/calendar/tsrc/tcal_tz_instance.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pimappservices/calendar/tsrc/tcal_tz_instance.cpp Tue Feb 02 10:12:19 2010 +0200 @@ -0,0 +1,472 @@ +// 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 +#include +#include +#include +#include +#include +#include + +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 months; + CleanupClosePushL(months); + months.AppendL(EAugust); + rule.SetByMonth(months); + CleanupStack::PopAndDestroy(&months); + + RArray 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 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 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 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 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 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 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); + }