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

 #include <f32file.h>

 #include <s32file.h>

 #include <schinfointernal.h>

 #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<TScheduleEntryInfo2>* entryList = new(ELeave) CArrayFixFlat<TScheduleEntryInfo2>(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<TTaskSchedulerCondition>* conditionList = new(ELeave) CArrayFixFlat<TTaskSchedulerCondition>(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);

 	}