// Copyright (c) 1999-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 "t_schsend.h"

#include <msvschedulesend.h>

#include <bautils.h>

#include <smss.rsg>

#include <msvschedulesettings.h>

#include <msvsysagentaction.h>

#include <barsc.h>

#include <msvoffpeaktime.h>

#include <csmsaccount.h>

RTest& operator<<(RTest& aTest, TTime t);

CTrapCleanup* theCleanup;

//_LIT(KSmsResourceFile, "z:\\System\\Data\\SMSS.RSC");

//Horrible hack because nmake thinks &myFun is illegal but GCC needs the & sign

#ifdef __WINS__

#define PFUN

#else

#define PFUN &

#endif

void doMainL(RTest& aTest)

	{

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install( scheduler );

	CSchSendTest* schSendTest = CSchSendTest::NewL(aTest);

	CleanupStack::PushL(schSendTest);

	schSendTest->StartL();

	CleanupStack::PopAndDestroy(2); //schSendTest, iScheduler

	aTest.Printf(_L("\nWaiting 3 seconds before closing...\n"));

	User::After(3000000);

	}

GLDEF_C TInt E32Main()

	{

	RTest test(_L("Scheduled Sending Test Harness"));

	__UHEAP_MARK;

	test.Title();

	test.Start(_L("Scheduled Sending Test Harness"));

	theCleanup = CTrapCleanup::New();

	test(theCleanup !=NULL);

	TRAPD(error,doMainL(test));

	test(error==KErrNone);

	delete theCleanup;

	test.Printf(_L("Completed with return code %d"),error);

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return KErrNone;

	}

CSchSendTest* CSchSendTest::NewL(RTest& aTest)

	{

	CSchSendTest* self = new (ELeave) CSchSendTest(aTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(); //self

	return self;

	}

CSchSendTest::CSchSendTest(RTest& aTest)

: CSchSendTestUtils(aTest)

	{

	}

void CSchSendTest::TestPackageL()

	{

	TMsvSchedulePackage pkg;

	pkg.iCommandId = 100000;

	pkg.iId = 123456;

	TestPackageL(pkg);

	pkg.iCommandId = 20000;

	pkg.iPollProgress = 1000000;

	TestPackageL(pkg);

	pkg.iParameter.Append(_L8("Hello"));

	TestPackageL(pkg);

	pkg.iParameter.Fill('a');

	TestPackageL(pkg);

	}

void CSchSendTest::TestPackageL(const TMsvSchedulePackage& aPackage)

	{

	TTaskInfo info;

	TMsvSchedulePackage pkg;

	HBufC* buf = NULL;

	aPackage.PackLC(info, buf);

	pkg.UnpackL(info, *buf);

	AssertL(aPackage == pkg);

	CleanupStack::PopAndDestroy(buf);

	}

void CSchSendTest::RunAutoL()

	{

	// Two groups of tests

	TestSendErrorActionsL();

	TestOffPeakTimesL();

	// Individual tests

	AssertL(DoTest(PFUN CSchSendTest::TestPackageL, _L("Schedule Package")));

	AssertL(DoTest(PFUN TestSysAgentActionsL, _L("Sys Agent Actions")));

	AssertL(DoTest(PFUN TestScheduleSettingsL, _L("Schedule Settings")));

	AssertL(DoTest(PFUN TestSchedulingMessagesL, _L("Scheduling Messages")));

	AssertL(DoTest(PFUN TestSchedulingOldMessagesL, _L("Scheduling Old Messages")));

	AssertL(DoTest(PFUN TestSchedulingMessagesTwiceL, _L("Scheduling Messages Twice")));

	AssertL(DoTest(PFUN TestReschedulingMessagesL, _L("ReScheduling Messages")));

	AssertL(DoTest(PFUN TestReschedulingNonScheduledMessagesL, _L("ReScheduling Non Scheduled Messages")));

	AssertL(DoTest(PFUN TestDeletingMessagesL, _L("Deleting Messages")));

	AssertL(DoTest(PFUN TestDeletingNonScheduledMessagesL, _L("Deleting Non Scheduled Messages")));

	AssertL(DoTest(PFUN TestSchedulingOffPeakMessagesL, _L("Off Peak Messages")));

	//AssertL(DoTest(PFUN TestCheckScheduleL, _L("CheckScheduleL")));

	AssertL(HeapTest(PFUN TestSysAgentActionsL, _L("Sys Agent Actions")));

	AssertL(HeapTest(PFUN TestSchedulingMessagesL, _L("Scheduling Messages")));

	AssertL(HeapTest(PFUN TestSchedulingOffPeakMessagesL, _L("Off Peak Messages")));

	AssertL(HeapTest(PFUN TestSchedulingOldMessagesL, _L("Scheduling Old Messages")));

	AssertL(HeapTest(PFUN TestSchedulingMessagesTwiceL, _L("Scheduling Messages Twice")));

	AssertL(HeapTest(PFUN TestReschedulingMessagesL, _L("ReScheduling Messages")));

	AssertL(HeapTest(PFUN TestReschedulingNonScheduledMessagesL, _L("ReScheduling Non Scheduled Messages")));

	AssertL(HeapTest(PFUN TestDeletingMessagesL, _L("Deleting Messages")));

	AssertL(HeapTest(PFUN TestDeletingNonScheduledMessagesL, _L("Deleting Non Scheduled Messages")));

	}

void CSchSendTest::TestSendErrorActionsL()

	{

/*

	Public functions of TMsvSendErrorAction:

	Tested	Function

	-------	---------------------------------------------------------------------

	Yes		TMsvSendErrorAction();

	Yes		void InternalizeL(RReadStream& aReadStream);

	Yes		void ExternalizeL(RWriRTestream& aWriRTestream) const;

	Yes		void Reset();

	Yes		void SetMaxRetries(const TInt16 aMaxRetries);

	Yes		TInt16 MaxRetries() const;

	Public functions of CMsvSendErrorActions:

	Tested	Function

	-------	---------------------------------------------------------------------

	Yes		static CMsvSendErrorActions* NewL();

	Yes		void AddSendErrorActionL(const TMsvSendErrorAction& aAction);

	Yes		const TInt RemoveSendErrorAction(const TInt aError);

	Yes		const TInt GetSendErrorAction(const TInt aError, TMsvSendErrorAction& aAction) const;

	Yes		void StoreL(CMsvStore& aStore) const;

	Yes		void RestoreL(CMsvStore& aStore);

			void RestoreFromResourceL(TResourceReader& aReader);

	Yes		void SetErrorsL(const CArrayFixFlat<TMsvSendErrorAction>& aActions);

	// but broken

	Yes		const CArrayFixFlat<TMsvSendErrorAction>& Errors() const;

	Yes		const TMsvSendErrorAction& Default() const;

	Yes		void SetDefault(const TMsvSendErrorAction& aAction);

*/

	AssertL(DoTest(PFUN TestSendErrorActions1L, _L("TestSendErrorActions1")));

	AssertL(DoTest(PFUN TestDefaultL, _L("TestDefault")));

	AssertL(DoTest(PFUN TestSendErrorActions3L, _L("TestSendErrorActions3")));

	AssertL(DoTest(PFUN TestErrorsL, _L("TestErrors")));

	AssertL(DoTest(PFUN TestStoringL, _L("TestStoring")));

	AssertL(DoTest(PFUN TestRemovingL, _L("TestRemoving")));

	//AssertL(DoTest(PFUN TestSendErrorActions4L, _L("TestSendErrorActions4")));

	}

void CSchSendTest::TestOffPeakTimesL()

	{

/*

	Public functions of TMsvOffPeakTime:

	Tested	Function

	-------	---------------------------------------------------------------------

	Yes		TMsvOffPeakTime();

	Yes		TMsvOffPeakTime(const TDay aDay, const TInt aHour, const TInt aMinute, const TTimeIntervalMinutes aValidityPeriod);

	Yes		void ExternalizeL (RWriRTestream &) const;

    Yes		void InternalizeL (RReadStream &);

	Yes		void Reset();

	Yes		const TDay Day() const;

	Yes		void SetDay(const TDay aDay);

	Yes		const TInt Hour() const;

	Yes		void SetHour(const TInt aHour);

	Yes		const TInt Minute() const;

	Yes		void SetMinute(const TInt aMinute);

	Yes		const TTimeIntervalMinutes ValidityPeriod() const;

	Yes		void SetValidityPeriod(const TTimeIntervalMinutes aValidityPeriod);

	Yes		const TTime NextTimeInclusive(const TTime& aFromTime) const;

	Public functions of CMsvOffPeakTimes:

	Tested	Function

	-------	---------------------------------------------------------------------

	Yes		CMsvOffPeakTimes();

	Yes		void StoreL(CMsvStore& aStore) const;

	Yes		void RestoreL(CMsvStore& aStore);

			const TInt GetNextOffPeakTime(const TTime& aFromTime, TMsvOffPeakTime& aNext, TTime& aNextTime) const;

	// This last one tested by TestReschedulingMessagesL()

*/

	AssertL(DoTest(PFUN TestOffPeakTimes1L, _L("TestOffPeakTimes1L")));

	AssertL(DoTest(PFUN TestOffPeakTimes3L, _L("TestOffPeakTimes3L")));

	}

void CSchSendTest::TestSendErrorActions1L()

	{

// --- Testing TMsvSendErrorAction ---

	iRTest.Next(_L("TestSendErrorActions1L()"));

	TMsvSendErrorAction action1, action2;

	action1.iAction			= ESendActionRetryLater;

	action1.iRetries		= ESendRetriesFixed;

	action1.iRetrySpacing	= ESendRetrySpacingStatic;

	action1.iError			= KErrNotFound;

	action1.SetMaxRetries(10);

	action2 = action1;

	AssertL(action1==action2);

	action1.SetMaxRetries(1);

	AssertL(action1.MaxRetries() == 1);

	action1.SetMaxRetries(200);

	AssertL(action1.MaxRetries() == 200);

	action1.Reset();

	TMsvSendErrorAction action3;

	AssertL(action1==action3);

	}

void CSchSendTest::TestSendErrorActions3L()

	{

	TMsvSendErrorAction action1, action2;

	action1.iAction			= ESendActionRetryLater;

	action1.iRetries		= ESendRetriesFixed;

	action1.iRetrySpacing	= ESendRetrySpacingStatic;

	action1.iError			= KErrNotFound;

	action1.SetMaxRetries(10);

	action1.Reset();

	AssertL(action1==action2);

	}

void CSchSendTest::TestDefaultL()

	{

	CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(actions);

	TMsvSendErrorAction action1, action2;

	action1.iAction			= ESendActionRetryLater;

	action1.iRetries		= ESendRetriesFixed;

	action1.iRetrySpacing	= ESendRetrySpacingStatic;

	action1.iError			= KErrNotFound;

	action1.SetMaxRetries(10);

	actions->SetDefault(action1);

	action2 = actions->Default();

	AssertL(action2 == action1);

	CleanupStack::PopAndDestroy(); // actions

	}

void CSchSendTest::TestSendErrorActions5L()

	{

	CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(actions);

	TMsvSendErrorAction action1, action2, action3;

	action1.iError = KErrGeneral;

	action2.iError = KErrNotSupported;

	actions->AddSendErrorActionL(action1);

	actions->AddSendErrorActionL(action2);

	TInt error = actions->GetSendErrorAction(KErrNotSupported, action3);

	AssertL(error == KErrNone);

	AssertL(action3 == action2);

	error = actions->GetSendErrorAction(KErrGeneral, action3);

	AssertL(action3 == action1);

	error = actions->GetSendErrorAction(KErrNotFound, action3);

	AssertL(error == KErrNotFound);

	CleanupStack::PopAndDestroy(); // actions

	}

void CSchSendTest::TestErrorsL()

	{

	CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(actions);

	CArrayFixFlat<TMsvSendErrorAction>* actionArray1 = new (ELeave) CArrayFixFlat<TMsvSendErrorAction>(20);

	CleanupStack::PushL(actionArray1);

	TMsvSendErrorAction test1, test2;

	test1.iError = KErrAbort;

	test2.iError = KErrTooBig;

	TInt offSet = _FOFF(TMsvSendErrorAction, iError);

	TKeyArrayFix key(offSet, ECmpTInt);

	actionArray1->InsertIsqL(test1, key);

	actionArray1->InsertIsqL(test2, key);

	actions->SetErrorsL(*actionArray1);

	const CArrayFixFlat<TMsvSendErrorAction>& actionArray2 = actions->Errors();

	AssertL(actionArray1->Count()==actionArray2.Count());

	for(int i = 0; i < actionArray1->Count(); i++)

		{

		// VC can't find my operator== if I do this the obvious one-line way

		TMsvSendErrorAction one = (*actionArray1)[i];

		TMsvSendErrorAction two = actionArray2[i];

		AssertL(one==two);

		}

	CleanupStack::PopAndDestroy(2); // actions, actionArray1

	}

void CSchSendTest::TestStoringL()

	{

	CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(actions);

	CMsvSendErrorActions* actions2 = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(actions2);

	// access sms account settings

	CSmsAccount* account = CSmsAccount::NewLC();

	CMsvScheduleSettings* scheduleSettings = CMsvScheduleSettings::NewL();

	CleanupStack::PushL(scheduleSettings);

	CMsvOffPeakTimes* offPeakTimes = new(ELeave) CMsvOffPeakTimes;

	CleanupStack::PushL(offPeakTimes);

	CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(errorActions);

	CMsvSysAgentActions* sysAgentActions = new (ELeave) CMsvSysAgentActions();

	CleanupStack::PushL(sysAgentActions);

	// read existing settings

	TRAPD(ignor, account->LoadSettingsL(*scheduleSettings, *offPeakTimes, *errorActions, *sysAgentActions));

	// write

	account->SaveSettingsL(*scheduleSettings, *offPeakTimes, *actions, *sysAgentActions);

	// read 

	account->LoadSettingsL(*scheduleSettings, *offPeakTimes, *actions2, *sysAgentActions);

	// restore settings	

	account->SaveSettingsL(*scheduleSettings, *offPeakTimes, *errorActions, *sysAgentActions);

	CleanupStack::PopAndDestroy(4, scheduleSettings); // sysAgentActions, errorActions, offPeakTimes, scheduleSettings 

	AssertL(*actions==*actions2);

	CleanupStack::PopAndDestroy(3); //actions, actions2, entry/account

	}

void CSchSendTest::TestRemovingL()

	{

	TMsvSendErrorAction a1, a2, a3;

	a1.iError = -3;

	a2.iError = -4;

	a3.iError = -5;

	CMsvSendErrorActions* actions1 = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(actions1);

	CMsvSendErrorActions* actions2 = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(actions2);

	actions1->AddSendErrorActionL(a1);

	actions1->AddSendErrorActionL(a2);

	actions1->AddSendErrorActionL(a3);

	actions2->AddSendErrorActionL(a1);

	actions2->AddSendErrorActionL(a3);

	actions1->RemoveSendErrorAction(-4);

	AssertL(*actions1==*actions2);

	CleanupStack::PopAndDestroy(2); //actions1 and 2

	}

/*void CSchSendTest::TestSendErrorActions4L()

	{

// --- Reading CMsvSendErrorActions from a resource file ---

	iRTest.Next(_L("TestSendErrorActions4L"));

	CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL();

	CleanupStack::PushL(actions);

	TFileName fileName;

	TParse parse;

    parse.Set(KSmsResourceFile, &fileName, 0);

	fileName=parse.FullName();

	BaflUtils::NearestLanguageFile(iFs, fileName);

	RResourceFile iResourceFile;

	iResourceFile.OpenL(iFs, fileName);

	TResourceReader reader;

	HBufC8* rBuf = iResourceFile.AllocReadLC(ERROR_ACTIONS);

	reader.SetBuffer(rBuf);

	actions->RestoreFromResourceL(reader);

	iResourceFile.Close();

	CleanupStack::PopAndDestroy(2); //actions, rBuf

	} */

void CSchSendTest::TestOffPeakTimes1L()

	{

	iRTest.Next(_L("TestOffPeakTimes1L"));

	//Make an off peak time

	TInt hour = 10;

	TInt min = 10;

	TDay day = EMonday;

	TTimeIntervalMinutes valPrd = 5*60;

	TMsvOffPeakTime offPeak;

	offPeak.SetHour(hour);

	offPeak.SetMinute(min);

	offPeak.SetDay(day);

//	offPeak.SetValidityPeriod(-1);  PASSED OK

	offPeak.SetValidityPeriod(valPrd);

	//Check that it worked

	AssertL(offPeak.Hour() == hour);

	AssertL(offPeak.Minute() == min);

	AssertL(offPeak.Day() == day);

	AssertL(offPeak.ValidityPeriod() == valPrd);

	TTime now;

	now.HomeTime();

	TTime nextTime = now;

	nextTime = offPeak.NextTimeInclusive(now);

	TBuf<30> dateString;

	now.FormatL(dateString,(_L("%D%M%Y%/0%1%/1%2%/2%3%/3  %-B%:0%J%:1%T%:2%S%.%*C4%:3%+B")));

    Printf(_L("Now: "));

	Printf(dateString);

	Printf(_L("\n"));

	nextTime.FormatL(dateString,(_L("%D%M%Y%/0%1%/1%2%/2%3%/3  %-B%:0%J%:1%T%:2%S%.%*C4%:3%+B")));

    Printf(_L("Next Time: "));

	Printf(dateString);

	Printf(_L("\n"));

	AssertL(StartsAt(offPeak, nextTime));

	TTime fourHoursAgo = now - (TTimeIntervalHours) 4;

	TDateTime dtFourHoursAgo = fourHoursAgo.DateTime();

	hour = dtFourHoursAgo.Hour();

	min  = dtFourHoursAgo.Minute();

	day = fourHoursAgo.DayNoInWeek();

	valPrd = 8*60;  // valid for eight hours

	TMsvOffPeakTime nowIsOffPeak(day, hour, min, valPrd);

	nextTime = nowIsOffPeak.NextTimeInclusive(now);

    Printf(_L("Now: "));

	iRTest<<now;

    Printf(_L("\nFour Hours Ago: "));

	iRTest<<fourHoursAgo;

	Printf(_L("\nNext Time: "));

	iRTest<<nextTime;

	AssertL(nextTime < now);

	AssertL(StartsAt(nowIsOffPeak, fourHoursAgo));

	}

void CSchSendTest::TestOffPeakTimes3L()

	{

	iRTest.Next(_L("TestOffPeakTimes3L"));