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

// System includes
#include <asclisoundplay.h>

// Globals
static TTime time;
static TAlarmId id;
static TInt ret;

// Type definitions
typedef CArrayFixFlat<TASCliSoundPlayDefinition> CPlayIntervalArray;

// This define appears in sa_mng.cpp - update it if it changes there!
#define KDefaultAlarmCycleStartOffsetMinutes	{0,1,2,3,5,10,20,30,45,60,90,120,180,240,KErrNotFound};

static TAlarmId AddAlarm(TTime aTime)
	{
	TASShdAlarm alarm;
	alarm.Category() = KASCliCategoryClock;
	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;
	alarm.NextDueTime() = aTime;
	//
	TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alarm) == KErrNone, __LINE__);
	const TAlarmId id = alarm.Id();
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	return id;
	}

static TAlarmId AddUtcAlarm(TTime aTime)
	{
	TASShdAlarm alarm;
	alarm.Category()=KASCliCategoryClock;
	alarm.RepeatDefinition()=EAlarmRepeatDefintionRepeatOnce;
	alarm.SetUtcNextDueTime(aTime);
	//
	TheAlarmTest(TheAlarmTest.Session().AlarmAdd(alarm) == KErrNone, __LINE__);
	const TAlarmId id = alarm.Id();
	TheAlarmTest(id != KNullAlarmId, __LINE__);

	return id;
	}



static void TestDefaultSoundInfoL()
//
//	Get default sound info details
//
	{
	TheAlarmTest.Test().Next(_L("Test the default sound play intervals"));
	// When the server is started, the alarm sound intervals should currently be
	// set to their defaults defined in KDefaultAlarmCycleStartOffsetMinutes

	// Initialise sound array with default values
	CPlayIntervalArray* array = new(ELeave) CPlayIntervalArray(20);
	CleanupStack::PushL(array);

	// Get default sound intervals
	TheAlarmTest.Session().GetAlarmPlayIntervalsL(*array);

	// Check that the default values are correct
	const TInt minuteCycle[]=KDefaultAlarmCycleStartOffsetMinutes;
	TInt i = 0;
	TInt offset = minuteCycle[i];
	while (offset != KErrNotFound)
		{
		const TASCliSoundPlayDefinition& item = array->At(i);
		TheAlarmTest(item.Offset().Int() == offset, __LINE__);
		TheAlarmTest(item.Duration().Int() == KDefaultSoundPlayDurationInSeconds, __LINE__);
		offset = minuteCycle[++i];
		}
	CleanupStack::PopAndDestroy();
	}

	
static void TestAlarmFunctionalityL()
	{
	TheAlarmTest.Test().Next(_L("Test alarm functionality"));

	TheAlarmTest.TestClearStoreL();

	time.HomeTime();
	time += TTimeIntervalMinutes(1);
	id = AddAlarm(time);
	TASShdAlarm alarm;
	ret = TheAlarmTest.Session().GetAlarmDetails(id, alarm);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TAlarmCategory category;
	ret = TheAlarmTest.Session().GetAlarmCategory(id, category);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TheAlarmTest(category == KASCliCategoryClock, __LINE__);
	ret = TheAlarmTest.Session().SetAlarmStatus(id, EAlarmStatusDisabled);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TAlarmStatus status;
	ret = TheAlarmTest.Session().GetAlarmStatus(id, status);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TheAlarmTest(status == EAlarmStatusDisabled, __LINE__);
	}


	
static void TestAlarmDataFunctionalityL()
	{
	TheAlarmTest.Test().Next(_L("Test alarm data functionality"));

	time.HomeTime();
	time += TTimeIntervalMinutes(1);
	id = AddAlarm(time);

	_LIT8(KAlarmData, "some 8-bit data to attach to the alarm");

	ret = TheAlarmTest.Session().AlarmDataAttachL(id, KAlarmData());
	TheAlarmTest(ret == KErrNone, __LINE__);
	ret = TheAlarmTest.Session().AlarmDataSize(id);
	TheAlarmTest(ret > 0, __LINE__);

	HBufC8* temp = HBufC8::NewLC(KAlarmData().Size());
	TPtr8 pData(temp->Des());
	ret = TheAlarmTest.Session().GetAlarmData(id, pData);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TheAlarmTest(pData.CompareC(KAlarmData()) == 0, __LINE__);
	CleanupStack::PopAndDestroy(temp);
	}


static void TestOtherFunctionalityL()
	{
	TheAlarmTest.Test().Next(_L("Test other functionality"));

	TheAlarmTest.TestClearStoreL();

	time.HomeTime();
	time += TTimeIntervalMinutes(1);
	id = AddAlarm(time);
	time -= TTimeIntervalSeconds(30);
	id = AddAlarm(time);

	ret = TheAlarmTest.Session().SetAlarmStatusByCategory(KASCliCategoryClock, EAlarmStatusEnabled);
	TheAlarmTest(ret == KErrNone, __LINE__);

	ret = TheAlarmTest.Session().GetAlarmCountForCategory(KASCliCategoryClock);
	TheAlarmTest(ret == 2, __LINE__);

	RArray<TAlarmCategory> categories;
	TheAlarmTest.Session().GetAvailableCategoryListL(categories);
	TheAlarmTest(categories.Count() == 1, __LINE__);
	categories.Reset();

	RArray<TAlarmId> ids;
	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, ids);
	TheAlarmTest(ids.Count() == 2, __LINE__);
	ids.Reset();

	ret = TheAlarmTest.Session().AlarmCountByState(EAlarmStateQueued);
	TheAlarmTest(ret == 2, __LINE__);

	TheAlarmTest.Session().GetAlarmIdListL(ids);
	TheAlarmTest(ids.Count() == 2, __LINE__);
	ids.Reset();

	TAlarmId nextDueId;
	ret = TheAlarmTest.Session().GetNextDueAlarmId(nextDueId);
	TheAlarmTest(ret == KErrNone && nextDueId == id, __LINE__);

	ret = TheAlarmTest.Session().NumberOfAlarmsActiveInQueue();
	TheAlarmTest(ret == 2, __LINE__);

	ret = TheAlarmTest.Session().AlarmDeleteAllByCategory(KASCliCategoryClock, EFalse);
	TheAlarmTest(ret == KErrNone, __LINE__);
	}

static void TestUtcAlarmFunctionalityL()
	{
	TheAlarmTest.Test().Next(_L("Test UTC alarm functionality"));

	TheAlarmTest.TestClearStoreL();

	time.HomeTime();
	time += TTimeIntervalMinutes(1);
	id = AddUtcAlarm(time);
	TASShdAlarm alarm;
	ret = TheAlarmTest.Session().GetAlarmDetails(id, alarm);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TAlarmCategory category;
	ret = TheAlarmTest.Session().GetAlarmCategory(id, category);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TheAlarmTest(category == KASCliCategoryClock, __LINE__);
	ret = TheAlarmTest.Session().SetAlarmStatus(id, EAlarmStatusDisabled);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TAlarmStatus status;
	ret = TheAlarmTest.Session().GetAlarmStatus(id, status);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TheAlarmTest(status == EAlarmStatusDisabled, __LINE__);
	}


	
static void TestUtcAlarmDataFunctionalityL()
	{
	TheAlarmTest.Test().Next(_L("Test alarm data functionality"));

	time.HomeTime();
	time += TTimeIntervalMinutes(1);
	id = AddUtcAlarm(time);

	_LIT8(KAlarmData, "some 8-bit data to attach to the alarm");

	ret = TheAlarmTest.Session().AlarmDataAttachL(id, KAlarmData());
	TheAlarmTest(ret == KErrNone, __LINE__);
	ret = TheAlarmTest.Session().AlarmDataSize(id);
	TheAlarmTest(ret > 0, __LINE__);

	HBufC8* temp = HBufC8::NewLC(KAlarmData().Size());
	TPtr8 pData(temp->Des());
	ret = TheAlarmTest.Session().GetAlarmData(id, pData);
	TheAlarmTest(ret == KErrNone, __LINE__);
	TheAlarmTest(pData.CompareC(KAlarmData()) == 0, __LINE__);
	CleanupStack::PopAndDestroy(temp);
	}


static void TestOtherFunctionalityUtcL()
	{
	TheAlarmTest.Test().Next(_L("Test other functionality"));

	TheAlarmTest.TestClearStoreL();

	time.HomeTime();
	time += TTimeIntervalMinutes(1);
	id = AddUtcAlarm(time);
	time -= TTimeIntervalSeconds(30);
	id = AddUtcAlarm(time);

	ret = TheAlarmTest.Session().SetAlarmStatusByCategory(KASCliCategoryClock, EAlarmStatusEnabled);
	TheAlarmTest(ret == KErrNone, __LINE__);

	ret = TheAlarmTest.Session().GetAlarmCountForCategory(KASCliCategoryClock);
	TheAlarmTest(ret == 2, __LINE__);

	RArray<TAlarmCategory> categories;
	TheAlarmTest.Session().GetAvailableCategoryListL(categories);
	TheAlarmTest(categories.Count() == 1, __LINE__);
	categories.Reset();

	RArray<TAlarmId> ids;
	TheAlarmTest.Session().GetAlarmIdListForCategoryL(KASCliCategoryClock, ids);
	TheAlarmTest(ids.Count() == 2, __LINE__);
	ids.Reset();

	ret = TheAlarmTest.Session().AlarmCountByState(EAlarmStateQueued);
	TheAlarmTest(ret == 2, __LINE__);

	TheAlarmTest.Session().GetAlarmIdListL(ids);
	TheAlarmTest(ids.Count() == 2, __LINE__);
	ids.Reset();

	TAlarmId nextDueId;
	ret = TheAlarmTest.Session().GetNextDueAlarmId(nextDueId);
	TheAlarmTest(ret == KErrNone && nextDueId == id, __LINE__);

	ret = TheAlarmTest.Session().NumberOfAlarmsActiveInQueue();
	TheAlarmTest(ret == 2, __LINE__);

	ret = TheAlarmTest.Session().AlarmDeleteAllByCategory(KASCliCategoryClock, EFalse);
	TheAlarmTest(ret == KErrNone, __LINE__);
	}


static void TestSoundControlL()
	{
	TheAlarmTest.Test().Next(_L("Test sound control"));

	TheAlarmTest.TestClearStoreL();

	ret = TheAlarmTest.Session().SetAlarmSoundState(EAlarmGlobalSoundStateOff);
	TheAlarmTest(ret == KErrNone, __LINE__);

	TAlarmGlobalSoundState soundState;
	ret = TheAlarmTest.Session().GetAlarmSoundState(soundState);
	TheAlarmTest(ret == KErrNone && soundState == EAlarmGlobalSoundStateOff, __LINE__);

	time.HomeTime();
	time += TTimeIntervalMinutes(1);
	ret = TheAlarmTest.Session().SetAlarmSoundsSilentUntil(time);
	TheAlarmTest(ret == KErrNone, __LINE__);

	ret = TheAlarmTest.Session().CancelAlarmSilence();
	TheAlarmTest(ret == KErrNone, __LINE__);

	ret = TheAlarmTest.Session().SetAlarmSoundsSilentFor(1);
	TheAlarmTest(ret == KErrNone, __LINE__);

	ret = TheAlarmTest.Session().GetAlarmSoundsSilentUntil(time);
	TheAlarmTest(ret == KErrNone, __LINE__);

	if (!TheAlarmTest.Session().AlarmSoundsTemporarilySilenced())
		{
		User::Leave(KErrGeneral);
		}
	}

	
static void TestStartUpAndShutDownL()
	{
#ifdef _DEBUG
#ifdef __WINS__
	TheAlarmTest.Test().Next(_L("Test start up and shut down"));

	TheAlarmTest.Session().__DbgShutDownServer();
	TheAlarmTest.TestStartServers();
	TheAlarmTest.TestClearStoreL();

	time.HomeTime();
	time += TTimeIntervalMinutes(5);
	id = AddAlarm(time);

	TheAlarmTest.Test().Printf(_L("\nDebug only - shutting down server\n"));
	TheAlarmTest.Session().__DbgShutDownServer();
	User::After(3 * 1000000);

	TheAlarmTest.TestStartServers();

	TAlarmId nextDueId;
	ret = TheAlarmTest.Session().GetNextDueAlarmId(nextDueId);
	TheAlarmTest(ret == KErrNone && nextDueId == id, __LINE__);

	time -= TTimeIntervalMinutes(1);
	id = AddAlarm(time);

	TheAlarmTest.Session().__DbgShutDownServer();
	User::After(3 * 1000000);

	TheAlarmTest.TestStartServers();

	ret = TheAlarmTest.Session().GetNextDueAlarmId(nextDueId);
	TheAlarmTest(ret == KErrNone && nextDueId == id, __LINE__);
#endif
#endif
	}


static void TestStartUpAndShutDownUtcL()
	{
#ifdef _DEBUG
#ifdef __WINS__
	TheAlarmTest.Test().Next(_L("Test start up and shut down with UTC Alarms"));

	TheAlarmTest.Session().__DbgShutDownServer();
	TheAlarmTest.TestStartServers();
	TheAlarmTest.TestClearStoreL();

	time.HomeTime();
	time += TTimeIntervalMinutes(5);
	id = AddUtcAlarm(time);

	TheAlarmTest.Test().Printf(_L("\nDebug only - shutting down server\n"));
	TheAlarmTest.Session().__DbgShutDownServer();
	User::After(3 * 1000000);

	TheAlarmTest.TestStartServers();

	TAlarmId nextDueId;
	ret = TheAlarmTest.Session().GetNextDueAlarmId(nextDueId);
	TheAlarmTest(ret == KErrNone && nextDueId == id, __LINE__);

	time -= TTimeIntervalMinutes(1);
	id = AddUtcAlarm(time);

	TheAlarmTest.Session().__DbgShutDownServer();
	User::After(3 * 1000000);

	TheAlarmTest.TestStartServers();

	ret = TheAlarmTest.Session().GetNextDueAlarmId(nextDueId);
	TheAlarmTest(ret == KErrNone && nextDueId == id, __LINE__);
#endif
#endif
	}


static void DoTestsL()
	{
	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);

	TheAlarmTest.Next(_L("Connecting to server"));
	const TInt r = TheAlarmTest.Session().Connect();
	TheAlarmTest(r == KErrNone, __LINE__);
	TheAlarmTest.TestClearStoreL();

	TestAlarmFunctionalityL();
	TestAlarmDataFunctionalityL();
	TestOtherFunctionalityL();

	TestStartUpAndShutDownL();

	TheAlarmTest.TestClearStoreL();

	TestDefaultSoundInfoL();
	TestUtcAlarmFunctionalityL();
	TestUtcAlarmDataFunctionalityL();
	TestOtherFunctionalityUtcL();
	TestSoundControlL();

	TestStartUpAndShutDownUtcL();

	CleanupStack::PopAndDestroy(scheduler);
	}

void DoOOMTestL()
	{
	TheAlarmTest.Test().Printf(_L("starting OOM test\n"));

	//reserve space on cleanup stack
	for(TInt i=0; i<1000; i++)
		{
		CleanupStack::PushL(&i);
		}
	CleanupStack::Pop(1000);

	TInt ret=KErrNoMemory;
	TInt failAt=0;
	while (ret!=KErrNone)
		{
		failAt++;
		__UHEAP_SETFAIL(RHeap::EDeterministic,failAt);
		__UHEAP_MARK;
		TRAP(ret, DoTestsL());
		if (ret!=KErrNone)
			{
			__UHEAP_MARKEND;
			}
		__UHEAP_RESET;
		TheAlarmTest(ret==KErrNoMemory||ret==KErrNone, __LINE__);
		}
	}

/**
@SYMTestCaseID PIM-TOOMTEST-0001
*/	
GLDEF_C TInt E32Main()
//
// Test the alarm server.
//
	{
	__UHEAP_MARK;
	TInt ret = KErrNone;
	CTrapCleanup* cleanup = CTrapCleanup::New();
	if (!cleanup)
		{
		return KErrNoMemory;
		}

	TheAlarmTest.Start(_L("@SYMTestCaseID PIM-TOOMTEST-0001"));
	TheAlarmTest.Title();
	TheAlarmTest.TestStartServers();

	TRAPD(error, DoOOMTestL());

	TheAlarmTest(error == KErrNone, __LINE__);
	TRAP(ret,TheAlarmTest.EndL());
    TheAlarmTest.Test().Close();

	ASTstAlarmTest::Close();

	delete cleanup;
	__UHEAP_MARKEND;
	return ret;
	}