// Copyright (c) 2005-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 <e32test.h>

#include <f32file.h>

#include <tz.h>

#include <schinfo.h>

#include <schinfointernal.h>

#include <schtask.h>

#include "Thelpers.h"

_LIT(KHBufTest, "This is a CScheduledTask test");

_LIT(KTestName,	"Scheduled Task");

RTest	TheTest(KTestName);

// persistent file for externalize and internalize test

_LIT(KFileName,"_:\\CSheduledTask.dat");

static TBuf<32> fileName;

LOCAL_D RFs TheFsSession;

//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__)

/**

@file

@SYMTestCaseID				SYSLIB-SCHSVR-CT-0202

@SYMTestCaseDesc 			Check that externalize executes correctly for tasks with local based times

@SYMTestPriority 			low

@SYMTestActions  			Create a local time based instance of CSheduledTask and externalize

@SYMTestExpectedResults		The test must not fail.

@SYMPREQ					PREQ234

*/

LOCAL_D void doLocalTimeExternalizeTestL()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0202 CScheduledTask Externalize Test (local time) "));

	TheTest.Printf(_L("Tests with timezone set to Europe, London"));	

	RTz tz;

	tz.Connect();

	CTzId* tzId = CTzId::NewL(2592); //set the timezone to Europe/London

	CleanupStack::PushL(tzId);

	tz.SetTimeZoneL(*tzId);

	TheTest.Printf(_L("Tests with DST on"));	

	//set the current utc time to 8.55am, 15 May 2005 -Daylight savings apply on this date

	TDateTime date(2005, EMay, 15, 8, 55, 0, 0);

	TTime time(date);

	TInt err = SchSvrHelpers::SetUTCTimeL(time); 

	TEST(err == 0);

	User::After(KOneSecond * 3);	

	// set data for CScheduledTask construction

	TTaskInfo taskInfo;

	HBufC* taskdata = HBufC::NewLC(KHBufTest().Length());

	TPtr pData(taskdata->Des());

	pData.Append(KHBufTest);

	TSecurityInfo securityInfo;

	CScheduledTask* extTask = new(ELeave) CScheduledTask(taskInfo, 

										taskdata, 

										ETimeSchedule, 

										securityInfo);

	CleanupStack::Pop(taskdata); //taskdata now owned by newTask

	CleanupStack::PushL(extTask);

	// set due time, 63284489700000000 microseconds since 1st Jan 0 AD

	// This is local time

	TDateTime extDate(2005, EMay, 15, 8, 55, 0, 0);

	TTime extTime(extDate);

	TTime extDueTime(extTime);

	extTask->OnDue(TTsTime(extDueTime,EFalse));

	// externalize

	RFile extFile;

	TFileName extFileName(fileName);

	TEST2(extFile.Replace(TheFsSession,extFileName,EFileWrite), KErrNone);

	RFileBuf extBuf;

	CleanupClosePushL(extBuf);

	extBuf.Attach(extFile);

	RWriteStream extStream(&extBuf);

	TRAP(err, extTask->ExternalizeL(extStream));

	TEST(err == KErrNone);

	CleanupStack::PopAndDestroy(3, tzId);

	}

/**

@file

@SYMTestCaseID				SYSLIB-SCHSVR-CT-0203

@SYMTestCaseDesc 			Check that internalize executes correctly for tasks with local based times

@SYMTestPriority 			low

@SYMTestActions  			Create a local time based instance of CSheduledTask which does an internalize

@SYMTestExpectedResults		The test must not fail.

@SYMPREQ					PREQ234

*/

LOCAL_D void doLocalTimeInternalizeTestL()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0203 CScheduledTask Internalize Test (local time) "));

	// internalize

	RFile intFile;

	TFileName intFileName(fileName);

	TEST2(intFile.Open(TheFsSession,intFileName,EFileRead), KErrNone);

	RFileBuf intBuf;

	CleanupClosePushL(intBuf);

	intBuf.Attach(intFile);

	RReadStream intStream(&intBuf);

	CScheduledTask* intTask = CScheduledTask::NewLC(intStream);

	// due date/time is 8.55am, 15 May 2005 -Daylight savings apply on this date

	TTsTime ttime = intTask->ValidUntil();

	TTime time = ttime.GetLocalTime();

	TDateTime dtime = time.DateTime();

	TEST(dtime.Year() == 2005);

	TEST(dtime.Month() == EMay);

	TEST(dtime.Day() == 15);

	TEST(dtime.Hour() == 8);

	TEST(dtime.Minute() == 55);

	TEST(dtime.Second() == 0);

	TEST(dtime.MicroSecond() == 0);

	// test offset - 3600 seconds (1 hour) because time of device is in BST

	TTimeIntervalSeconds offset(3600);

	TEST(ttime.GetOffset() == offset);

	// test difference between returned values

	TTime utcTime = intTask->ValidUntil().GetUtcTime();

	TTime localTime = intTask->ValidUntil().GetLocalTime();

	Int64 t = localTime.Int64() - utcTime.Int64();

	TTimeIntervalSeconds diff((localTime.Int64() - utcTime.Int64())/1000000);

	TEST(diff == offset);

	// test that this instance is home time and not UTC

	TEST(ttime.IsUtc() == EFalse);

	// test data

	HBufC* data = const_cast<HBufC*>(&(intTask->Data()));

	TEST(data->Compare(KHBufTest) == 0);

	CleanupStack::PopAndDestroy(2, &intBuf);

	}

/**

@file

@SYMTestCaseID				SYSLIB-SCHSVR-CT-0239 

@SYMTestCaseDesc 			Check that externalize executes correctly for tasks with UTC based times

@SYMTestPriority 			low

@SYMTestActions  			Create a UTC time based instance of CSheduledTask and externalize

@SYMTestExpectedResults		The test must not fail.

@SYMPREQ					PREQ234

*/

LOCAL_D void doUtcExternalizeTestL()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0239 CScheduledTask Externalize Test (UTC) "));

	TheTest.Printf(_L("Tests with timezone set to Europe, London"));	

	RTz tz;

	tz.Connect();

	CTzId* tzId = CTzId::NewL(2592); //set the timezone to Europe/London

	CleanupStack::PushL(tzId);

	tz.SetTimeZoneL(*tzId);

	TheTest.Printf(_L("Tests with DST on"));	

	//set the current utc time to 8.55am, 15 May 2005 -Daylight savings apply on this date

	TDateTime date(2005, EMay, 15, 8, 55, 0, 0);

	TTime time(date);

	TInt err = SchSvrHelpers::SetUTCTimeL(time); 

	TEST(err == 0);

	User::After(KOneSecond * 3);	

	// set data for CScheduledTask construction

	TTaskInfo taskInfo;

	HBufC* taskdata = HBufC::NewLC(KHBufTest().Length());

	TPtr pData(taskdata->Des());

	pData.Append(KHBufTest);

	TSecurityInfo securityInfo;

	CScheduledTask* extTask = new(ELeave) CScheduledTask(taskInfo, 

										taskdata, 

										ETimeSchedule, 

										securityInfo);

	CleanupStack::Pop(taskdata); //taskdata now owned by newTask

	CleanupStack::PushL(extTask);

	// set due time, 63284489700000000 microseconds since 1st Jan 0 AD

	// This is UTC time

	TDateTime extDate(2005, EMay, 15, 8, 55, 0, 0);

	TTime extTime(extDate);

	TTime extDueTime(extTime);

	extTask->OnDue(TTsTime(extDueTime,ETrue));

	// externalize

	RFile extFile;

	TFileName extFileName(fileName);

	TEST2(extFile.Replace(TheFsSession,extFileName,EFileWrite), KErrNone);

	RFileBuf extBuf;

	CleanupClosePushL(extBuf);

	extBuf.Attach(extFile);

	RWriteStream extStream(&extBuf);

	TRAP(err, extTask->ExternalizeL(extStream));

	TEST(err == KErrNone);

	CleanupStack::PopAndDestroy(3, tzId);

	}

/**

@file

@SYMTestCaseID				SYSLIB-SCHSVR-CT-0240	

@SYMTestCaseDesc 			Check that internalize executes correctly for tasks with UTC times

@SYMTestPriority 			low

@SYMTestActions  			Create a UTC based instance of CSheduledTask which does an internalize

@SYMTestExpectedResults		The test must not fail.

@SYMPREQ					PREQ234

*/

LOCAL_D void doUtcInternalizeTestL()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-SCHSVR-CT-0240 CScheduledTask Internalize Test (UTC) "));

	// internalize

	RFile intFile;

	TFileName intFileName(fileName);

	TEST2(intFile.Open(TheFsSession,intFileName,EFileRead), KErrNone);

	RFileBuf intBuf;

	CleanupClosePushL(intBuf);

	intBuf.Attach(intFile);

	RReadStream intStream(&intBuf);

	CScheduledTask* intTask = CScheduledTask::NewLC(intStream);

	// due date/time is 8.55am, 15 May 2005 -Daylight savings apply on this date

	TTsTime ttime = intTask->ValidUntil();

	TTime time = ttime.GetUtcTime();

	TDateTime dtime = time.DateTime();

	TEST(dtime.Year() == 2005);

	TEST(dtime.Month() == EMay);

	TEST(dtime.Day() == 15);

	TEST(dtime.Hour() == 8);

	TEST(dtime.Minute() == 55);

	TEST(dtime.Second() == 0);

	TEST(dtime.MicroSecond() == 0);

	// test offset - should be zero because the object is UTC based

	TTimeIntervalSeconds offset(0);

	TEST(ttime.GetOffset() == offset);

	// test difference between returned values

	TTime utcTime = intTask->ValidUntil().GetUtcTime();

	TTime localTime = intTask->ValidUntil().GetLocalTime();

	Int64 t = localTime.Int64() - utcTime.Int64();

	TTimeIntervalSeconds diff((localTime.Int64() - utcTime.Int64())/1000000);

	// difference should be the kernel offset from UTC	

	offset = User::UTCOffset();

	TEST(diff == offset);

	// test that this instance is UTC and not local time based

	TEST(ttime.IsUtc());

	// test data

	HBufC* data = const_cast<HBufC*>(&(intTask->Data()));

	TEST(data->Compare(KHBufTest) == 0);

	CleanupStack::PopAndDestroy(2, &intBuf);

	}

static void RunTestsL()

	{

	doLocalTimeExternalizeTestL();

	doLocalTimeInternalizeTestL();

	doUtcExternalizeTestL();

	doUtcInternalizeTestL();

	}

//***********************************************************************************

GLDEF_C TInt E32Main()

 	{

	CTrapCleanup* tc = CTrapCleanup::New();

	TEST(tc != NULL);

	__UHEAP_MARK;

	fileName.Copy(KFileName);

	fileName[0] = RFs::GetSystemDriveChar();

	TInt err = TheFsSession.Connect();

	TEST(err == KErrNone);

	TheTest.Title();

	TheTest.Start(_L("Unit tests for CScheduledTask"));

	TRAP(err, ::RunTestsL())

	TEST(err == KErrNone);

	(void)TheFsSession.Delete(fileName);

	TheFsSession.Close();

	TheTest.End();

	TheTest.Close();

	__UHEAP_MARKEND;

	delete tc;

	return(KErrNone);

	}