// 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:

//

// System includes

#include <e32base.h>

#include <e32test.h>

#include <f32file.h>

// User includes

#include "TServerSessionEngine.h"

// Literal constants

_LIT(KTest,		"server session engine test");

// Constants

const TAlarmCategory KASCliCategoryTest		= { 0x101F5031 };

// Globals

static RTest TheTest(KTest);

void Test1L(CTestServerSessionEngine* aSessionEngine)

	{

	TheTest.Next(_L("Test 1"));

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

	// Test1 tests

	//

	// AlarmAddL

	// AlarmDeleteL

	// AlarmCountByCategory

	// AlarmCountByState

	// AlarmIdListByStateLC

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

	aSessionEngine->ClearAlarmStoreL();

	RArray<TAlarmId> alarmIds;

	CleanupClosePushL(alarmIds);

	//add 10 alarms (category KASCliCategoryClock)

	for(TInt ii=1; ii<=10; ii++)

		{

		TInt secondsFromNow = (ii)*2;

		TAlarmId id = aSessionEngine->AddAlarmWithSpecificTimeL(secondsFromNow);

		alarmIds.AppendL(id);

		TInt numberOfAlarms = aSessionEngine->Engine().AlarmCountByCategory(KASCliCategoryClock);

		TheTest(numberOfAlarms == ii, __LINE__);

		}

	//check states of alarms

	TInt alarmCount=0;

	//states should be:

	// 10 x EAlarmStateQueued

	alarmCount = aSessionEngine->Engine().AlarmCountByState(EAlarmStateQueued);

	TheTest(alarmCount == 10, __LINE__);

	//wait for alarm to expire

	aSessionEngine->AwaitNotificationL();

	CActiveScheduler::Start();

	//states should be:

	// 1 x EAlarmStateNotifying

	// 9 x EAlarmStateQueued

	alarmCount = aSessionEngine->Engine().AlarmCountByState(EAlarmStateNotifying);

	TheTest(alarmCount == 1, __LINE__);

	alarmCount = aSessionEngine->Engine().AlarmCountByState(EAlarmStateQueued);

	TheTest(alarmCount == 9, __LINE__);

	//wait for another alarm to expire

	CActiveScheduler::Start();

	//states should be:

	// 1 x EAlarmStateNotifying

	// 1 x EAlarmStateWaitingToNotify

	// 8 x EAlarmStateQueued

	alarmCount = aSessionEngine->Engine().AlarmCountByState(EAlarmStateNotifying);

	TheTest(alarmCount == 1, __LINE__);

	alarmCount = aSessionEngine->Engine().AlarmCountByState(EAlarmStateWaitingToNotify);

	TheTest(alarmCount == 1, __LINE__);

	alarmCount = aSessionEngine->Engine().AlarmCountByState(EAlarmStateQueued);

	TheTest(alarmCount == 8, __LINE__);

	//last 8 alarms in our array should correspond to array of alarms with state queued

	RArray<TAlarmId>* alarmsWithStateQueued = aSessionEngine->Engine().AlarmIdListByStateLC(EAlarmStateQueued);

		for(TInt jj=0; jj<8; jj++)

		{

		TheTest(alarmIds[jj+2] == (*alarmsWithStateQueued)[jj], __LINE__);

		}

	alarmsWithStateQueued->Close();

	CleanupStack::PopAndDestroy(alarmsWithStateQueued);

	//delete all alarms individually

	for(TInt count=alarmIds.Count(); count>0; count--)

		{

		aSessionEngine->Engine().AlarmDeleteL(alarmIds[count-1]);

		}

	CleanupStack::PopAndDestroy();//alarmIds

	}

void Test2L(CTestServerSessionEngine* aSessionEngine)

	{

	TheTest.Next(_L("Test 2"));

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

	// Test2 tests

	//

	// AlarmDetailsL

	// AlarmCategoryL

	// SetAlarmStatusByCategoryL

	// AlarmCountByCategory

	// DeleteAllAlarmsByCategoryL

	// AlarmCategoryListLC

	// AlarmIdListByCategoryLC

	// SetAlarmStatusL

	// AlarmStatus

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

	aSessionEngine->ClearAlarmStoreL();

	//add 5 alarms with category KASCliCategoryClock

	for(TInt ii=0; ii<5; ii++)

		{

		aSessionEngine->AddAlarmWithSpecificCategoryL(KASCliCategoryClock);

		}

	//get list of categories - should contain only KASCliCategoryClock

	RArray<TAlarmCategory>* alarmCategories = aSessionEngine->Engine().AlarmCategoryListLC();

	TheTest(alarmCategories->Count() == 1 && (*alarmCategories)[0] == KASCliCategoryClock, __LINE__);

	alarmCategories->Close();

	CleanupStack::PopAndDestroy(alarmCategories);

	//add 5 alarms with category KASCliCategoryTest

	for(TInt jj=0; jj<5; jj++)

		{

		aSessionEngine->AddAlarmWithSpecificCategoryL(KASCliCategoryTest);

		}

	RArray<TAlarmCategory>* alarmCategories2 = aSessionEngine->Engine().AlarmCategoryListLC();

	TheTest(alarmCategories2->Count() == 2, __LINE__);

	alarmCategories2->Close();

	CleanupStack::PopAndDestroy(alarmCategories2);

	//add another 10 alarms with category KASCliCategoryClock

	for(TInt kk=0; kk<10; kk++)

		{

		aSessionEngine->AddAlarmWithSpecificCategoryL(KASCliCategoryClock);

		}

	//get alarms with category KASCliCategoryClock

	RArray<TAlarmId>* alarms = aSessionEngine->Engine().AlarmIdListByCategoryLC(KASCliCategoryClock);

	TInt count = alarms->Count();

	TheTest(count == 15, __LINE__);

	//check each alarm has category KASCliCategoryClock

	for(TInt mm=0; mm<15; mm++)

		{

		//directly

		TheTest(aSessionEngine->Engine().AlarmCategoryL((*alarms)[mm]) == KASCliCategoryClock, __LINE__);

		//indirectly

		TASSrvAlarm alarm(aSessionEngine->ServerWideData());

		aSessionEngine->Engine().AlarmDetailsL((*alarms)[mm], alarm);

		TheTest(alarm.Category() == KASCliCategoryClock, __LINE__);

		}

	alarms->Close();

	CleanupStack::PopAndDestroy(alarms);

	//should now have 15 alarms with category KASCliCategoryClock and 5 with category KASCliCategoryTest

	TheTest(aSessionEngine->Engine().AlarmCountByCategory(KASCliCategoryClock)==15 &&

		aSessionEngine->Engine().AlarmCountByCategory(KASCliCategoryTest)==5, __LINE__);

	//disable all KASCliCategoryClock alarms

	aSessionEngine->Engine().SetAlarmStatusByCategoryL(KASCliCategoryClock, EAlarmStatusDisabled);

	TheTest(aSessionEngine->Engine().NumberOfActiveAlarmsInQueue()==5, __LINE__);

	//try to delete all KASCliCategoryTest orphaned alarms (should be none)

	aSessionEngine->Engine().DeleteAllAlarmsByCategoryL(KASCliCategoryTest, ETrue);

	TheTest(aSessionEngine->Engine().NumberOfActiveAlarmsInQueue()==5, __LINE__);

	//delete all KASCliCategoryTest alarms

	aSessionEngine->Engine().DeleteAllAlarmsByCategoryL(KASCliCategoryTest, EFalse);

	TheTest(aSessionEngine->Engine().NumberOfActiveAlarmsInQueue()==0, __LINE__);

	//re-enable the KASCliCategoryClock alarms

	aSessionEngine->Engine().SetAlarmStatusByCategoryL(KASCliCategoryClock, EAlarmStatusEnabled);

	TheTest(aSessionEngine->Engine().NumberOfActiveAlarmsInQueue()==15, __LINE__);

	//create a new enabled alarm

	TAlarmId id = aSessionEngine->AddAlarmWithSpecificCategoryL(KASCliCategoryClock);

	TheTest(aSessionEngine->Engine().NumberOfActiveAlarmsInQueue()==16, __LINE__);

	//check status

	TheTest(aSessionEngine->Engine().AlarmStatusL(id) == EAlarmStatusEnabled, __LINE__);

	//disable it

	aSessionEngine->Engine().SetAlarmStatusL(id, EAlarmStatusDisabled);

	TheTest(aSessionEngine->Engine().NumberOfActiveAlarmsInQueue()==15, __LINE__);

	TheTest(aSessionEngine->Engine().AlarmStatusL(id) == EAlarmStatusDisabled, __LINE__);

	//delete all remaining alarms

	aSessionEngine->Engine().DeleteAllAlarmsByCategoryL(KASCliCategoryClock, EFalse);

	TheTest(aSessionEngine->Engine().NumberOfActiveAlarmsInQueue()==0, __LINE__);

	}

static void doTestsL()

	{

	// this is a WINS test only, because it tests the functionality of the alarm server

	// engine directly.  The tests are repeated in TClientSession which exercises the same

	// functionality through a client session

#ifdef __WINS__

	CTestServerSessionEngine* sessionEngine = CTestServerSessionEngine::NewLC();

	//

	TheTest.Next(_L("Start tests"));

	Test1L(sessionEngine);

	Test2L(sessionEngine);

	CleanupStack::PopAndDestroy(sessionEngine);

#else

	TheTest.Printf(_L("\nThis is a WINS test only\n"));

#endif

	}

/**

@SYMTestCaseID PIM-TSERVERSESSIONENGINEMAIN-0001

*/	

TInt E32Main()

	{

	__UHEAP_MARK;

	//

	TheTest.Title();

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if	(!cleanup)

		return KErrNoMemory;

	//

	TheTest.Start(_L("@SYMTestCaseID PIM-TSERVERSESSIONENGINEMAIN-0001"));

	//

	TRAPD(err, doTestsL());

	TheTest(err == KErrNone, __LINE__);

	delete cleanup;

	TheTest.End();

	TheTest.Close();

	__UHEAP_MARKEND;

	return KErrNone;

	}