diff -r 000000000000 -r e4d67989cc36 genericservices/taskscheduler/Test/TSCheduleEntryInfo2/TU_TSCH_ScheduleEntryInfo2.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/genericservices/taskscheduler/Test/TSCheduleEntryInfo2/TU_TSCH_ScheduleEntryInfo2.cpp Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,454 @@ +// Copyright (c) 2004-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: +// T_ScheduleEntryInfo2.cpp +// This file contains the implementation of test classe for TScheduleEntryInfo2. +// +// + +#include +#include +#include +#include +#include "Thelpers.h" + +#include "SCHINFO.H" + +_LIT(KTestName, "TScheduleEntryInfo2 Tests"); +RTest TheTest(KTestName); + +static RFs TheFsSession; +_LIT(KFileName,"_:\\tscheduleinfo2.dat"); +static TBuf<32> fileName; + +// +// +//Test macroses and functions + +static void Check(TInt aValue, TInt aLine) + { + if(!aValue) + { + (void)TheFsSession.Delete(fileName); + TheTest(EFalse, aLine); + } + } +static void Check(TInt aValue, TInt aExpected, TInt aLine) + { + if(aValue != aExpected) + { + RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); + (void)TheFsSession.Delete(fileName); + TheTest(EFalse, aLine); + } + } +#define TEST(arg) ::Check((arg), __LINE__) +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__) + + +/** +State accessor for the TScheduleEntryInfo2 object under test. +*/ +class TScheduleEntryInfo2_StateAccessor + { + +public: + void TestDefaultConstructor(); + void TestCopyConstructorOverloadedConstructor(); + + //utility Get and Set methods + void TestIntervalTypeSetIntervalType(); + void TestStartTimeSetStartTime(); + void TestIntervalSetInterval(); + void TestValidityPeriodSetValidityPeriod(); + void TestNonExportedConstructor(); + void TestExternalizeInternalizeL(); + }; + + + +/** +@file +@SYMTestCaseID SYSLIB-SCHSVR-CT-0231 +@SYMTestCaseDesc Check the default constructor +@SYMTestPriority low +@SYMTestActions Creates an instance of TScheduleEntryInfo2 using the default constructor + anc checks that the data has been properly initialised +@SYMTestExpectedResults The test must not fail. +@SYMPREQ PREQ234 +*/ +void TScheduleEntryInfo2_StateAccessor::TestDefaultConstructor() + { + //Default constructor called + //Sets Start Time to 0 UTC time + //the interval type to 0, + //the interval to 0, + //the validityPeriod to 0 + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0231 Test default constructor ")); + TScheduleEntryInfo2 entry; + + TEST(entry.iIntervalType==0); + TEST(entry.iStartTime.GetUtcTime() == TTime(0)); + TEST(entry.iInterval == 0); + TEST(entry.iValidityPeriod == TTimeIntervalMinutes(0)); + } + + +/** +@file +@SYMTestCaseID SYSLIB-SCHSVR-CT-0232 +@SYMTestCaseDesc Check the copy constructor and the overloaded constructor +@SYMTestPriority low +@SYMTestActions Creates an instance of TScheduleEntryInfo2 using the overloaded + constructor and another instance of TScheduleEntryInfo2 using the copy constructor. + Then checks that data of both instances are equal. +@SYMTestExpectedResults The test must not fail. +@SYMPREQ PREQ234 +*/ +void TScheduleEntryInfo2_StateAccessor::TestCopyConstructorOverloadedConstructor() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0232 Text contructors ")); + + TDateTime date(2005, EMay, 15, 8, 55, 0, 0); + TTime time(date); + TTsTime startTime(time, EFalse); + TIntervalType intervalType(EHourly); + TInt interval(1); + TTimeIntervalMinutes validityPeriod(60); + + TScheduleEntryInfo2 entry1(startTime, intervalType, interval, validityPeriod); + + TScheduleEntryInfo2 entry2(entry1); + + //Test entry1 == entry2 + TEST(entry1.StartTime().GetLocalTime() == entry2.StartTime().GetLocalTime()); + TEST(entry1.ValidityPeriod() == entry2.ValidityPeriod()); + TEST(entry1.Interval() == entry2.Interval()); + + } + + +/** +@file +@SYMTestCaseID SYSLIB-SCHSVR-CT-0233 +@SYMTestCaseDesc Check SetIntervalType and IntervalType. +@SYMTestActions Creates an instance of TScheduleEntryInfo2 using the default constructor. + Sets its interval type and checks that the returned value of IntervalType() + is equal to the one set initially. +@SYMTestExpectedResults The test must not fail. +@SYMPREQ PREQ234 +*/ +void TScheduleEntryInfo2_StateAccessor::TestIntervalTypeSetIntervalType() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0233 Test set and get for Interval Type ")); + + TScheduleEntryInfo2 scheduleEntryInfo; + + scheduleEntryInfo.SetIntervalType(TIntervalType(EHourly)); + TIntervalType intervalType = scheduleEntryInfo.IntervalType(); + TEST(intervalType == EHourly); + } + + +/** +@file +@SYMTestCaseID SYSLIB-SCHSVR-CT-0234 +@SYMTestCaseDesc Check SetStartTime() and StartTime() +@SYMTestPriority low +@SYMTestActions Creates an instance of TScheduleEntryInfo2 using the default constructor + Sets its start time using SetStartTime() and compares StartTime() returned value + to the one set initially. +@SYMTestExpectedResults The test must not fail. +@SYMPREQ PREQ234 +*/ +void TScheduleEntryInfo2_StateAccessor::TestStartTimeSetStartTime() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0234 Test start time set and get methods ")); + + TScheduleEntryInfo2 scheduleEntryInfo; + + TDateTime date(2005, EMay, 15, 8, 55, 0, 0); + TTime time(date); + TTsTime startTime(time, EFalse); + + scheduleEntryInfo.SetStartTime(startTime); + + TEST(scheduleEntryInfo.StartTime().GetLocalTime() == startTime.GetLocalTime()); + } + + +/** +@file +@SYMTestCaseID SYSLIB-SCHSVR-CT-0235 +@SYMTestCaseDesc Check SetInterval() and Intervale() +@SYMTestPriority low +@SYMTestActions Creates an instance of TScheduleEntryInfo2 using the default constructor + Sets its Interval using SetInterval() and compares the returned value of + Interval() to the one set initially. +@SYMTestExpectedResults The test must not fail. +@SYMPREQ PREQ234 +*/ +void TScheduleEntryInfo2_StateAccessor::TestIntervalSetInterval() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0235 Test set and get for Interval ")); + + TScheduleEntryInfo2 scheduleEntryInfo; + scheduleEntryInfo.SetInterval(1); + TEST(scheduleEntryInfo.Interval() == TInt(1)); + } + +/** +@file +@SYMTestCaseID SYSLIB-SCHSVR-CT-0236 +@SYMTestCaseDesc Check SetValidityPeriod() and ValidityPeriod() +@SYMTestPriority low +@SYMTestActions Creates an instance of TScheduleEntryInfo2 using the default constructor + Sets its validty period using SetValidityPeriod() and checks that ValidityPeriod() returns + the same value as the one set initially. +@SYMTestExpectedResults The test must not fail. +@SYMPREQ PREQ234 +*/ +void TScheduleEntryInfo2_StateAccessor::TestValidityPeriodSetValidityPeriod() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0236 Set and get for validity period ")); + TScheduleEntryInfo2 scheduleEntryInfo; + + scheduleEntryInfo.SetValidityPeriod(60); + TTimeIntervalMinutes retValidityPeriod = scheduleEntryInfo.ValidityPeriod(); + + TEST(retValidityPeriod == TTimeIntervalMinutes(60)); + + } + +/** +@file +@SYMTestCaseID SYSLIB-SCHSVR-CT-0237 +@SYMTestCaseDesc Check non exported constructor provided for use with the deprecated APIs +@SYMTestPriority low +@SYMTestActions Creates an instance of TScheduleEntryInfo using the default constructor, sets its member data, + and creates an instance of TScheduleEntryInfo2 using the provied constructor for use with deprecated APIs. + Then checks that TScheduleEntryInfo2 date is equal to TScheduleEntryInfo data. + +@SYMTestExpectedResults The test must not fail. +@SYMPREQ PREQ234 +*/ +void TScheduleEntryInfo2_StateAccessor::TestNonExportedConstructor() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0237 Test non exported constructor ")); + + TScheduleEntryInfo entry1; + entry1.iIntervalType = EHourly; + entry1.iStartTime = SchSvrHelpers::TimeBasedOnOffset(1); + + entry1.iInterval = 1; + entry1.iValidityPeriod = 20; + + TScheduleEntryInfo2 entry2(entry1); + + //test that scheduleEntryInfo2 startTime is local time + TEST(!entry2.iStartTime.IsUtc()); + + //test intervalType + TEST(entry2.iIntervalType == entry1.iIntervalType); + + //test interval + TEST(entry2.iInterval == entry1.iInterval); + + //test validity period + TEST(entry2.iValidityPeriod == entry1.iValidityPeriod); + } + + +/** +@file +@SYMTestCaseID SYSLIB-SCHSVR-CT-0238 +@SYMTestCaseDesc Check Exetrnalize and Internalize methods +@SYMTestPriority low +@SYMTestActions Creates an instance of TScheduleEntryInfo2 using the overloaded operator, externalizes it + to a file and then internalizes into another instance of TScheduleEntryInfo2. + Checks the externalized data is the same as the internalized one. +@SYMTestExpectedResults The test must not fail. +@SYMPREQ PREQ234 +*/ +void TScheduleEntryInfo2_StateAccessor::TestExternalizeInternalizeL() + { + + // Test externalise + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0238 \n=== Test TScheduleEntryInfo2::ExternalizeL\n")); + RFile file; + + + TFileName testFileName(fileName); + TEST2(file.Replace(TheFsSession,testFileName,EFileWrite|EFileRead), KErrNone); + RFileBuf buf; + CleanupClosePushL(buf); + buf.Attach(file); + RWriteStream stream(&buf); + + TTsTime ttime(SchSvrHelpers::TimeBasedOnOffset(1), EFalse); + TScheduleEntryInfo2 entry1(ttime, EHourly, 1, 20); + stream << entry1; //externalize TScheduleEntryInfo2 + buf.SynchL(); + CleanupStack::PopAndDestroy(&buf); + + + // Test internalise + TheTest.Next(_L("\n=== Test TScheduleEntryInfo2::InternalizeL\n")); + TScheduleEntryInfo2 entry2; + TInt err = file.Open(TheFsSession,testFileName,EFileRead); + TEST2(err, KErrNone); + RFileBuf buf2; + CleanupClosePushL(buf2); + buf2.Attach(file); + RReadStream stream2(&buf2); + + stream2 >> entry2; //internalize TScheduleEntryInfo2 + + //check iIntervalType + TEST(entry1.iIntervalType == entry2.iIntervalType); + + //check iStartTime + TEST(entry1.iStartTime.GetUtcTime() == entry2.iStartTime.GetUtcTime()); + + //check iInterval + TEST(entry1.iInterval == entry2.iInterval); + + //check iValidityPeriod + TEST(entry1.iValidityPeriod == entry2.iValidityPeriod); + + CleanupStack::PopAndDestroy(&buf2); + + } + +/** +@SYMTestCaseID SYSLIB-SCHSVR-CT-3368 +@SYMTestCaseDesc Task Scheduler: Persistent Schedules not ReScheduled on Device Bootup. +@SYMTestPriority High +@SYMTestActions This test does not have any capability. It tries to create persistent + time/ conduction schedule, it fail to create schedule + So return code will be KErrPermissionDenied +@SYMTestExpectedResults Test must not fail +@SYMDEF PDEF098080: Task Scheduler: Persistent Schedules not ReScheduled on Device Bootup. +*/ +LOCAL_D void CreatePersistentScheduleCapabilityTest() + { + __UHEAP_MARK; + + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-3368 \nPDEF098080: Task Scheduler: Persistent Schedules not ReScheduled on Device Bootup\n")); + + RScheduler TheScheduler; + TheTest(TheScheduler.Connect() == KErrNone);; + + //Create persistent time based schedule + CArrayFixFlat* entryList = new(ELeave) CArrayFixFlat(1); + CleanupStack::PushL(entryList); + TSchedulerItemRef ref; + + TTime ttime(SchSvrHelpers::TimeBasedOnOffset(0)); + TTsTime startTime1(ttime, EFalse); + + TScheduleEntryInfo2 entry1 (startTime1, EDaily, 1, 20); + entryList->AppendL(entry1); + + // Create the time base schedule and check capability policing is working . + TEST2(TheScheduler.CreatePersistentSchedule(ref, *entryList),KErrPermissionDenied); + + CleanupStack::PopAndDestroy(entryList); + + //Create persistent Condition based schedule + CArrayFixFlat* conditionList = new(ELeave) CArrayFixFlat(1); + CleanupStack::PushL(conditionList); + TSchedulerItemRef ref1; + + TTaskSchedulerCondition condition1; + const TUid KTestUid = TUid::Uid(0x01234566); + condition1.iCategory = KTestUid; + condition1.iKey = 10; + condition1.iState = 10; + condition1.iType = TTaskSchedulerCondition::EEquals; + conditionList->AppendL(condition1); + + // Create the condition base schedule and check capability policing is working . + TEST2(TheScheduler.CreatePersistentSchedule(ref1, *conditionList,startTime1),KErrPermissionDenied); + + CleanupStack::PopAndDestroy(conditionList); + TheScheduler.Close(); + + __UHEAP_MARKEND; + } + + +/** +Runs all the tests. +*/ +static void RunTestsL() + { + TheTest.Start(_L("=== Start TScheduleEntryInfo2 tests \n")); + + CreatePersistentScheduleCapabilityTest(); + + TScheduleEntryInfo2_StateAccessor* scheduleStateAccessor = new (ELeave) TScheduleEntryInfo2_StateAccessor; + + CleanupStack::PushL(scheduleStateAccessor); + + scheduleStateAccessor->TestDefaultConstructor(); + scheduleStateAccessor->TestCopyConstructorOverloadedConstructor(); + + //utility Get and Set methods + scheduleStateAccessor->TestIntervalTypeSetIntervalType(); + scheduleStateAccessor->TestStartTimeSetStartTime(); + scheduleStateAccessor->TestIntervalSetInterval(); + scheduleStateAccessor->TestValidityPeriodSetValidityPeriod(); + scheduleStateAccessor->TestNonExportedConstructor(); + + //utility externalize internalize + scheduleStateAccessor->TestExternalizeInternalizeL(); + CleanupStack::PopAndDestroy(); + } + + + +//*********************************************************************************** +GLDEF_C TInt E32Main() + { + CTrapCleanup* tc = CTrapCleanup::New(); + TEST(tc != NULL); + + __UHEAP_MARK; + + fileName.Copy(KFileName); + fileName[0] = RFs::GetSystemDriveChar(); + + TInt err = TheFsSession.Connect(); + TEST2(err, KErrNone); + + TheTest.Title(); + + TRAP(err, ::RunTestsL()) + TEST2(err, KErrNone); + + (void)TheFsSession.Delete(fileName); + TheFsSession.Close(); + TheTest.End(); + TheTest.Close(); + + __UHEAP_MARKEND; + + delete tc; + + return(KErrNone); + + } + + +