// Copyright (c) 2007-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:

// tcal_servershutdown:

// This test is intended to test the delay timer added to the calendar file before it is closed

// 

//

#include "tcal_servershutdown.h"

#include "calinstanceview.h"

#include "calinstance.h" 

#include "calrrule.h" 

#include <caliterator.h>

#include "calalarm.h" 

CServerShutdownTestManager::CServerShutdownTestManager(TInt aPriority):CActive(aPriority)

	{

	CActiveScheduler::Add(this);

	}

// Record a timestamp before initiating server shutdown

// Server shutdown period is checked against the expected range when the process exits

void CServerShutdownTestManager::RecordTimeStampBeforeServerShutdown()

	{

	iSrvTimerStartTicks = User::NTickCount();

	}

// Calculate server shutdown period and test that it is within the expected range

void CServerShutdownTestManager::TestServerShutdownTime()

	{

	TUint32 srvTimerStopTicks = User::NTickCount();

	TUint32 srvTimerShutdownPeriodTicks = srvTimerStopTicks - iSrvTimerStartTicks;

	TTimeIntervalMicroSeconds32 srvTimerShutdownPeriod = srvTimerShutdownPeriodTicks * iNanoTickPeriod;

	_LIT(KAgendaServerShutdownPeriod, "Agenda server shutdown period - %d microseconds\n");

	test.Printf(KAgendaServerShutdownPeriod, srvTimerShutdownPeriod);

	test(srvTimerShutdownPeriod >= KServerShutdownDelayMin);

	test(srvTimerShutdownPeriod <= KServerShutdownDelayMax);

	}

// Entry view progress callback

void CServerShutdownTestManager::Progress(TInt /*aPercentageCompleted*/)

	{

	_LIT(KDot, ".");

	test.Printf(KDot);

	_LIT(KUnexpectedCallback, "The index should already be built so we should not get progress callbacks\n");

	switch (iTestCase)

		{

		case ETestServerShutdownCancelWithIndexCancelled:

		case ETestServerShutdownCancelWithIndexShutdown:

			{

			test.Printf(KUnexpectedCallback);

			test(EFalse);

			}

			break;

		case ETestServerSingleSessionOpenTwiceShutdown:

		case ETestServerMultiSessionSingleFileOpen:

			{

			test.Printf(KUnexpectedCallback);

			test(EFalse);

			}

		break;

		default:

			{

			// do nothing

			}

			break;

		}

	}

// Entry view complete callback

void CServerShutdownTestManager::Completed(TInt aError)

	{

	_LIT(KEntryViewCompletedWithErr, "Entry View open complete with error = %d\n");

	test.Printf(KEntryViewCompletedWithErr, aError);

	switch(iTestCase)

		{

		case ETestServerShutdownOpenInvalidFileLeave:

			{

			test(aError == KErrNotFound);

			}

		break;

		case ETestServerShutdownOOMDeleteFile:

		case ETestServerShutdownOOMOpenCloseFile:

			{

			// OOM test will expectedly fail with KErrNoMemory

			test(aError == KErrNoMemory);

			}

		break;

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

		case ETestServerShutdownWithSystemStateNotificationAsync:

			{

			test(aError == KErrNone || aError == KErrCancel);

			}

		break;

#endif

		default:

			{

			test(aError == KErrNone);

			}

		break;

		}

	CActiveScheduler::Stop();

 	}

TBool CServerShutdownTestManager::NotifyProgress()

	{

	return ETrue;

	}

// The RunL is called when the agenda server process exits as a result of the logon to the process

// The process can exit in unexpected test cases' states and will result in an error

// If the process exits in an expected the test cases' state, the server shutdown period is calculated and checked against the expected time range

// There are other test cases' states where we expect the server to shutdown immediately e.g. after deleting a file, hence we do nothing

void CServerShutdownTestManager::RunL()

	{

	_LIT(KAgendaServerClosedWithStatus, "The agenda server has closed with iStatus = %d\n");

	_LIT(KAgendaServerUnexpectedClose, "The server closed down when it shouldn't have\n");

	_LIT(KInvalidTestCaseVariable, "The test case state variable was not set or was set to an invalid value\n");

	test.Printf(KAgendaServerClosedWithStatus, iStatus.Int());

	__ASSERT_ALWAYS(iStatus.Int() == KErrNone, User::Invariant());

	switch (iTestCase)

		{

		case ETestServerShutdownWithIndex:

			{

			// Calculate server shutdown period and test that it is within the expected range

			TestServerShutdownTime();

			}

		break;

		case ETestServerShutdownCancelWithIndexStart:

		case ETestServerShutdownCancelWithIndexCancelled:

			{

			// The server should not have shut down here

			test.Printf(KAgendaServerUnexpectedClose);

			test(EFalse);

			}

			break;

		case ETestServerShutdownCancelWithIndexShutdown:

			{

			// Calculate server shutdown period and test that it is within the expected range

			TestServerShutdownTime();

			}

			break;

		case ETestServerShutdownDeleteFile:

			{

			// Expecting the agenda server to shutdown immediately

			}

			break;

		case ETestServerShutdownDeleteMultiFiles:

			{

			// Calculate server shutdown period and test that it is within the expected range

			TestServerShutdownTime();

			}

			break;

		case ETestServerShutdownProcessExit:

			{

			// Expecting the agenda server to shutdown immediately

			}

			break;

		case ETestServerSingleSessionOpenTwiceStart:

			{

			// the server should not have shut down here since opening the file the second time should cancel the delay timer

			test.Printf(KAgendaServerUnexpectedClose);

			test(EFalse);

			}

			break;

		case ETestServerSingleSessionOpenTwiceShutdown:

			{

			// Calculate server shutdown period and test that it is within the expected range

			TestServerShutdownTime();

			}

			break;

		case ETestServerMultiSessionSingleFileOpenStart:

			{

			// the server should not have shut down here when a session out of multiple file sessions to multiple files is closed

			test.Printf(KAgendaServerUnexpectedClose);

			test(EFalse);

			}

			break;

		case ETestServerMultiSessionSingleFileOpenShutdown:

			{

			// Calculate server shutdown period and test that it is within the expected range

			TestServerShutdownTime();

			}

			break;

		case ETestServerMultiSessionMultiFileOpenStart:

			{

			// the server should not have shut down here when the last session to a calendar file is closed but there are other files open

			test.Printf(KAgendaServerUnexpectedClose);

			test(EFalse);

			}

			break;

		case ETestServerMultiSessionMultiFileOpenShutdown:

			{

			// Calculate server shutdown period and test that it is within the expected range

			TestServerShutdownTime();

			}

			break;				

		case ETestServerShutdownOpenInvalidFileLeave:

			{

			// Expecting the agenda server to shutdown immediately (not with a delay)

			}

			break;			

		case ETestServerShutdownv91CalendarFileConversion:

			{

			// Calculate server shutdown period and test that it is within the expected range

			TestServerShutdownTime();

			}

			break;

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

		case ETestServerShutdownWithSystemStateNotification:

			{

			TestSystemAckNotification();

			test (iAlarmServer.AlarmCountByState(EAlarmStateQueued) == 1);

			ClearAllAlarmsL();

			}

			break;

		case ETestServerShutdownWithSystemStateNotificationAsync:	

		case ETestServerShutdownWithSystemStateNotificationNormal:	

		case ETestServerShutdownWithSystemStateNotificationInstance:

			{

			TestSystemAckNotification();

			}

			break;

#endif

		default:

			{

			// The test case state variable was not set or was set to an invalid value

			test.Printf(KInvalidTestCaseVariable);

			test(EFalse);

			}

			break;

		};

	// Close the handle to the agenda server process

	iProcess.Close();

	// Stop the active scheduler since the agenda server process has now exited

	CActiveScheduler::Stop();

	}

void CServerShutdownTestManager::DoCancel()

	{

	iProcess.LogonCancel(iStatus);

	}

// Trigger an asynchronous delay which allows the server to shutdown and flag an error if it was unexpected

void CServerShutdownTestManager::AsyncDelay(TTimeIntervalMicroSeconds32 aMicroseconds)

	{

	_LIT(KAsyncDelayStart, "Async delay for %d microseconds is starting...\n");

	test.Printf(KAsyncDelayStart, aMicroseconds.Int());

	TCallBack callBack(CServerShutdownTestManager::AsyncDelayCallBack, this);

	iPeriodic->Start(aMicroseconds, aMicroseconds, callBack);

	CActiveScheduler::Start();

	}

// Called when the asynchronous delay expires

TInt CServerShutdownTestManager::AsyncDelayCallBack(TAny* aPtr)

	{

	_LIT(KAsyncDelayFinish, "...the delay has finished\n");

	test.Printf(KAsyncDelayFinish);

	static_cast<CServerShutdownTestManager*>(aPtr)->iPeriodic->Cancel();

	CActiveScheduler::Stop();

	return KErrNone;

	}

// Create a session to the agenda server

void CServerShutdownTestManager::CreateSessionL()

	{

	_LIT(KCreatingCalSession, "Creating a session\n");

	test.Printf(KCreatingCalSession);

	delete iSession;

	iSession = NULL;

	iSession = CCalSession::NewL();

	}

// Create an additional session to the agenda server

void CServerShutdownTestManager::CreateAdditionalSessionL()

	{

	_LIT(KCreatingCalAdditionalSession, "Creating an additional session\n");

	test.Printf(KCreatingCalAdditionalSession);

	delete iAdditionalSession;

	iAdditionalSession = NULL;

	iAdditionalSession = CCalSession::NewL();

	}

// Close the session and wait / do not wait for the agenda server to close

void CServerShutdownTestManager::CloseSession(TBool aWaitToClose)

	{

	_LIT(KClosingCalSession, "Closing the session\n");

	test.Printf(KClosingCalSession);

	delete iSession;

	iSession = NULL;

	if (aWaitToClose)

		{

		// Make sure any ecom sessions are destroyed before waiting for the agenda server to close

		REComSession::FinalClose();

		_LIT(KWaitingForAgendaServerClose, "Wait for the agenda server to close...\n");

		test.Printf(KWaitingForAgendaServerClose);

		CActiveScheduler::Start();

		}

	}

// Close the additional session to the agenda server

void CServerShutdownTestManager::CloseAdditionalSession(TBool aWaitToClose)

	{

	_LIT(KClosingAdditionalCalSession, "Closing the additional session\n");

	test.Printf(KClosingAdditionalCalSession);

	delete iAdditionalSession;

	iAdditionalSession = NULL;

	if (aWaitToClose)

		{

		// Make sure any ecom sessions are destroyed before waiting for the agenda server to close

		REComSession::FinalClose();

		_LIT(KWaitingForAgendaServerClose, "Wait for the agenda server to close...\n");

		test.Printf(KWaitingForAgendaServerClose);

		CActiveScheduler::Start();

		}

	}

// Create a calendar entry view 

void CServerShutdownTestManager::CreateEntryViewL(const TDesC& aCalFile, TBool aWaitToOpen)

	{

	_LIT(KCreatingCalEntryView, "Creating the Entry View\n");

	test.Printf(KCreatingCalEntryView);

	iSession->OpenL(aCalFile);

	iEntryView = CCalEntryView::NewL(*iSession, *this);

	if (aWaitToOpen)

		{

		CActiveScheduler::Start();

		}

	}

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

void CServerShutdownTestManager::CreateInstanceViewL(TBool aWaitToOpen)

	{

	_LIT(KCreatingCalInstanceView, "Creating an Instance View\n");

	test.Printf(KCreatingCalInstanceView);

	iInstanceView = CCalInstanceView::NewL(*iSession, *this);

	if (aWaitToOpen)

		{

		CActiveScheduler::Start();

		}

	}

// Create a test entry

void CServerShutdownTestManager::CreateEntry(const TDesC8& aGuid)

	{

	RPointerArray<CCalEntry> entryArray;

	CleanupClosePushL(entryArray);

//	TRAP_IGNORE(iEntryView->FetchL(aGuid, entryArray)); //If not found then this function leaves!

//	const TDateTime KEntryDateTime(2008, EApril, 17, 9, 0, 0, 0);

	TTime now;

	now.HomeTime();

	HBufC8* guid = aGuid.AllocLC();

	CCalEntry* entry = CCalEntry::NewL(CCalEntry::EAppt, guid, CCalEntry::EMethodNone, 0);

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);

	TCalTime startTime;

	TCalTime endTime;

	startTime.SetTimeLocalL(now + TTimeIntervalHours(1));

	endTime.SetTimeLocalL(now + TTimeIntervalHours(2));

	entry->SetStartAndEndTimeL(startTime, endTime);

    //Add an alarm

	CCalAlarm* alarm = CCalAlarm::NewL();

	CleanupStack::PushL(alarm);

	TTimeIntervalMinutes alarmMinutes(20);

	alarm->SetTimeOffset(alarmMinutes);

	entry->SetAlarmL(alarm);

	CleanupStack::PopAndDestroy(alarm);

	TInt success = 0;

	entryArray.AppendL(entry);

	test (entryArray.Count()==1);

	TRAPD(errStore, iEntryView->StoreL(entryArray, success));

	CleanupStack::PopAndDestroy(entry);

	CleanupStack::PopAndDestroy(&entryArray);

	}

#endif

// Create an additional calendar entry view 

void CServerShutdownTestManager::CreateAdditionalEntryViewL(const TDesC& aCalFile, TBool aWaitToOpen)

	{

	_LIT(KCreatingCalEntryView, "Creating an additional Entry View\n");

	test.Printf(KCreatingCalEntryView);

	iAdditionalSession->OpenL(aCalFile);

	iAdditionalEntryView = CCalEntryView::NewL(*iAdditionalSession, *this);

	if (aWaitToOpen)

		{

		CActiveScheduler::Start();

		}

	}

// Close the calendar file entry view 

void CServerShutdownTestManager::CloseEntryView()

	{

	_LIT(KClosingCalEntryView, "Closing the Entry View\n");

	test.Printf(KClosingCalEntryView);

	delete iEntryView;

	iEntryView = NULL;

	}

// Close the additional calendar file entry view 

void CServerShutdownTestManager::CloseAdditionalEntryView()

	{

	_LIT(KClosingCalAdditionalEntryView, "Closing the additional Entry View\n");

	test.Printf(KClosingCalAdditionalEntryView);

	delete iAdditionalEntryView;

	iAdditionalEntryView = NULL;

	}

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

void CServerShutdownTestManager::CloseInstanceView()

	{

	_LIT(KClosingCalInstanceView, "Closing the Instance View\n");

	test.Printf(KClosingCalInstanceView);

	delete iInstanceView;

	iInstanceView = NULL;

	}

#endif

CServerShutdownTestManager* CServerShutdownTestManager::NewLC(TInt aPriority)

	{

	CServerShutdownTestManager* self = new (ELeave) CServerShutdownTestManager(aPriority);

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

	}

CServerShutdownTestManager::~CServerShutdownTestManager()

	{

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	iSystemStateNotification.Close();

#endif

	delete iFileRegister;

	iPIMTestServer.Close();

	delete iPeriodic;

	iProcess.Close();

	delete iSession;

	delete iAdditionalSession;

	delete iEntryView;

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT

	delete iInstanceView;

#endif

	delete iAdditionalEntryView;

	}

void CServerShutdownTestManager::ConstructL()

	{

	iPeriodic = CPeriodic::NewL(EPriorityIdle);

	User::LeaveIfError(HAL::Get(HAL::ENanoTickPeriod, iNanoTickPeriod));

	User::LeaveIfError(iPIMTestServer.Connect());

	// Copy the test Calendar files from the ROM drive to the C: used by the test cases later

	iPIMTestServer.CopyFileL(KServerShutdownCalFileROM, KServerShutdownCalFileRAM);

	iPIMTestServer.CopyFileL(KServerShutdownCalFileMultiFileROM, KServerShutdownCalFileMultiFileRAM);

	iPIMTestServer.CopyFileL(KServerShutdown91CalFileROM, KServerShutdown91CalFileRAM);

	iFileRegister = CTestRegister::NewL();

	iFileRegister->RegisterL(KServerShutdownCalFile, EFileTypeAgn);

	iFileRegister->RegisterL(KServerShutdownCalFileMultifFile, EFileTypeAgn);

	iFileRegister->RegisterL(KServerShutdown91CalFile, EFileTypeAgn);

	// Start the console alarm alert server required by the agenda server

#if __WINS__

	CCalTestLibrary::StartAlarmServerL();

#endif

#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT	

	CreateSystemStateNotificationProperty();

	// Connect to the alarm server

	User::LeaveIfError(iAlarmServer.Connect());

	// Make sure that the alarm queue is empty.

	ClearAllAlarmsL();

#endif

	}

// Run all the test cases the delay added to the calendar file before it is closed

void CServerShutdownTestManager::RunAllTestsL()

	{

	// Test the file close delay timer with a single calendar file

	TestServerShutdownWithIndexL();

	// Test the cancellation of a file close delay timer with a single calendar file