// 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"
#include "testserver.h"

#ifdef __WINS__ 
const TUid KServerUid2={0x1000008D};
const TUid KServerUid3={0x101F502A};
#endif


//
// ----> ASTstAlarmTest (source)
//

//*************************************************************************************
EXPORT_C ASTstAlarmTest::ASTstAlarmTest()
: iTest(KAlarmTestCodeTitle)
	{
	iAlarmServer = RASCliSession();
	iInitialHomeTime.HomeTime();
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::Close()
	{
	ASTstAlarmTest* tlsSelf = reinterpret_cast<ASTstAlarmTest*>(Dll::Tls());
	delete tlsSelf;
	Dll::SetTls(NULL);
	}


//*************************************************************************************
EXPORT_C ASTstAlarmTest& ASTstAlarmTest::Self()
	{
	ASTstAlarmTest* tlsSelf = reinterpret_cast<ASTstAlarmTest*>(Dll::Tls());
	if	(!tlsSelf)
		{
		tlsSelf = new ASTstAlarmTest; 
		ASSERT(tlsSelf != NULL);
		Dll::SetTls(tlsSelf);
		}
	return *tlsSelf;
	}


//
//
//


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::operator()(TInt aResult, TInt aLineNum, const TText* aFileName)
	{
	if (!aResult)
		resetHomeTimeL();
	iTest.operator()(aResult, aLineNum, aFileName);
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::operator()(TInt aResult, TInt aLineNum)
	{
		
	if (!aResult)
		resetHomeTimeL();
	iTest.operator()(aResult, aLineNum);
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::operator()(TInt aResult)
	{
	if (!aResult)
		resetHomeTimeL();
	iTest.operator()(aResult);
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::Title()
	{
	iTest.Title();
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::Start(const TDesC& aHeading)
	{
	iTest.Start(aHeading);
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::Next(const TDesC& aHeading)
	{
	iTest.Next(aHeading);
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::EndL()
	{
	iTest.End();
	resetHomeTimeL();
	}

//*************************************************************************************
EXPORT_C void ASTstAlarmTest::UpLevel()
	{
	iTest.End();
	}


//
//
//


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::TestClearStoreL()
//
//	Clear any settings that may have been stored
//  Method could leave when trying to get list of all alarm categories in use within the alarm server.
//
	{
	iTest(iAlarmServer.Handle() != KNullHandle);

	// Delete all alarms
	RArray<TAlarmCategory> categories;
	iAlarmServer.GetAvailableCategoryListL(categories); 
	TInt count = categories.Count();
	for(TInt i=0; i<count; i++)
		{
		const TAlarmCategory category = categories[i];
		iTest(iAlarmServer.AlarmDeleteAllByCategory(category, EFalse) == KErrNone);
		}
	categories.Close();

	// Restore alarm sound
	iAlarmServer.SetAlarmSoundState(EAlarmGlobalSoundStateOn);

	// Check there aren't any queued alarms (not a particularly good
	// test, but better than nothing).
	count = iAlarmServer.NumberOfAlarmsActiveInQueue();
	iTest(!count);
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::WaitForNotificationBufferToBeEmptied(TRequestStatus& aStatus, TAlarmId& aAlarmId)
	{
	if	(aStatus == KRequestPending)
		return;

	iAlarmServer.NotifyChange(aStatus, aAlarmId);
	User::After(KTimeToWait);
	if	(aStatus == KRequestPending)
		return;
	User::WaitForRequest(aStatus);

	// Because of event bufferring inside the Alarm Server
	// We need to wait until there aren't any more events
	// in the buffer, and then attempt to cancel the request.
	//
	// Trying to cancel a request when the server has
	// already completed the message (because something
	// was in the buffer) results in the server panicking
	// the client.
	FOREVER
		{
		iTest(aStatus >= EAlarmChangeEventState && aStatus <= EAlarmChangeEventLast);
		iAlarmServer.NotifyChange(aStatus, aAlarmId);
		//
		// Wait a second so that we can tell if this really is
		// waiting for an event, or just for the Alarm Server
		// process to be given some scheduling time by the
		// kernel
		User::After(KTimeToWait);
		
		// If its still pending, then we should attempt
		// to cancel the request. Otherwise, if its not
		// pending, then the Alarm Server probably just
		// completed the request based upon the contents
		// of the event buffer.
		if	(aStatus == KRequestPending)
			break;
		else
			{
			// Eat the request and try again
			User::WaitForRequest(aStatus);
			}
		}
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::WaitForEvent(TInt aEvent, TRequestStatus& aStatus, TAlarmId& aAlarmId)
	{
	FOREVER
		{
		iAlarmServer.NotifyChange(aStatus, aAlarmId);
		User::WaitForRequest(aStatus);
		if	(aStatus == aEvent)
			return;
		}
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::TestEventBuffer(TInt aExpected, TRequestStatus& aStatus, TAlarmId& aAlarmId)
//
//	Check there the notification of this thread. Because notifications
//	in the new Alarm Server are bufferred, then the first notification
//	may not be the one we are looking for. Therefore we continue to
//  request notifications until the buffer is exhausted, at which point,
//	if we haven't yet seent the notification we were looking for, we
//	panic.
//
	{
	if	(aStatus != aExpected)
		{
		// Need to exhaust the event buffer

		// If the buffer is empty (server side) then the current
		// request will still be outstanding, therefore the test
		// has failed.
		User::After(KTimeToWait);
		iTest(aStatus != KRequestPending);

		// Eat current request
		User::WaitForRequest(aStatus);

		// Now go through each item in the buffer, requesting them
		// one by one
		FOREVER
			{
			iAlarmServer.NotifyChange(aStatus, aAlarmId);
			User::After(KTimeToWait);
			iTest(aStatus != KRequestPending);
			User::WaitForRequest(aStatus);
			if	(aStatus == aExpected)
				break;
			}
		}

	// Request another notification
	if	(aStatus != KRequestPending)
		{
		// Eat all the rest
		WaitForNotificationBufferToBeEmptied(aStatus, aAlarmId);
		}
	}


//*************************************************************************************
EXPORT_C TInt ASTstAlarmTest::CountOrphanedAlarmsL()
//
// Return the number of orphaned alarms
// Method could leave while getting the list of unique identifiers of all the alarms in the alarm server.
//
	{
	TASShdAlarm alarm;
	//
	RArray<TAlarmId> ids;
	iAlarmServer.GetAlarmIdListL(ids);   // Method could leave while getting the list of unique identifiers of all the alarms in the alarm server.

	TInt ret = 0;
	const TInt count = ids.Count();
	for(TInt i=0; i<count; i++)
		{
		const TAlarmId id = ids[i];
		const TInt error = iAlarmServer.GetAlarmDetails(id, alarm);

		// Alarm might have been deleted by another thread? Unlikely,
		// but best to check
		if	(error == KErrNone && alarm.HasBecomeOrphaned())
			++ret;
		}
	ids.Close();
	//
	return ret;
	}


//*************************************************************************************
EXPORT_C void ASTstAlarmTest::TestStartServers(TAny*
#if defined (__WINS__)
													 instructionSet
#endif
																   )
	{

#ifdef __WINS__ 

const TUidType serverUid(KNullUid,KServerUid2,KServerUid3);

	_LIT(KConsoleAlarmAlertServerImg,"ConsoleAlarmAlertServer");
	RProcess server;
    TInt ret;
	if ( instructionSet != NULL)
	   {   
		TBuf<256> cmdline;
		RArray<TInt>* temp = static_cast<RArray<TInt>*>(instructionSet);
	    TInt len = temp->Count();
		for(TInt i=0;i<len;i++)
		   {
			cmdline.Append((*temp)[i]);
		   }
        ret=server.Create(KConsoleAlarmAlertServerImg,cmdline,serverUid);
        iTest(ret == KErrNone);
	   }
    else 
		{
        ret=server.Create(KConsoleAlarmAlertServerImg,KNullDesC,serverUid);
        iTest(ret == KErrNone);
		}

	TRequestStatus stat;
	server.Rendezvous(stat);

	if (stat!=KRequestPending)
		{
		server.Kill(0);		// abort startup
		}
	else
		{
		server.Resume();	// logon OK - start the server
	}
#endif // __WINS__ 

	// Start the alarm server
	const TInt r = iAlarmServer.Connect();
	if	(r != KErrNone)
		{
		_LIT(KStartupFailure, "Couldn't connect to AS");
		User::Panic(KStartupFailure, 0);
		}
	}


void ASTstAlarmTest::resetHomeTimeL()
{
	RPIMTestServer serv;
    User::LeaveIfError(serv.Connect()); 
    serv.SetHomeTime(iInitialHomeTime);
    serv.Close();
}

//
// ----> Global Methods (source)
//

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