// 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_smcmsimtsytest.h"

#include <e32test.h>

#include <e32uid.h>

#include <e32std.h>

#include <smuthdr.h>

#include <txtrich.h> 

#include <smscmds.h>

#include <smsclnt.h>

#include <smsuaddr.h>

// Autotest library header file

#include <autotest.h>

#include <testconfigfileparser.h>

#include <simtsy.h>

#include <csmsaccount.h>

#include <e32property.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS  

#include <tmsvsmsentry.h>

#endif

// Global pointer for use by the autogTest.h macro's

CAutoTest* gAutoTest;

RTest gTest(_L("T_SmcmSimTsyTest Testrig"));

TBool HasCreatedSmsService = EFalse;

CTrapCleanup* theCleanup;

#define LOCAL_CHECKPOINT_CODE(a,b) a.TestCheckPointCodeL((b), (__FILE__), (__LINE__))

#define LOCAL_CHECKPOINT(a,b) a.TestCheckPointL((b), (__FILE__), (__LINE__))

#define LOCAL_CHECKPOINT_COMPARE(a,b,c,d) a.TestCheckPointCompareL((b),(c),(d),(__FILE__),(__LINE__))

//SMS Scripting

_LIT(KSmsScript,"smcmsimtsytest_config.txt");

_LIT(KSmsScriptFull,"\\msgtest\\sms\\smcmsimtsytest_config.txt");

void DeleteSmsStores(RFs& aFs)

	{

	_LIT(KReassemblyStoreName,"C:\\System\\Data\\smsreast.dat");

	_LIT(KSegmentationStoreName,"C:\\System\\Data\\smssegst.dat");

	aFs.Delete(KReassemblyStoreName);

	aFs.Delete(KSegmentationStoreName);

	}

CMessageSendStates::CMessageSendStates(TMsvId aId)

	{

	iId = aId;

	}

CMessageSendStates* CMessageSendStates::NewLC(TMsvId aId)

	{

	CMessageSendStates* self=new (ELeave) CMessageSendStates(aId);

	CleanupStack::PushL(self);

	//self->ConstructL();

	return self;

	}

CMessageSendStates* CMessageSendStates::NewL(TMsvId aId)

	{

	CMessageSendStates* self = NewLC(aId);

	CleanupStack::Pop(self);

	return self;

	}

void CMessageSendStates::ConstructL()

	{

	}

CMessageSendStates::~CMessageSendStates()

	{

	iStates.Close();

	}

RMessageSendStatesArray::RMessageSendStatesArray()

	{

	}

TInt RMessageSendStatesArray::Find(TMsvId aId) const

	{

	const RMessageSendStatesArray& sendArray = *this;

	TInt count = sendArray.Count();

	for (TInt i=0; i<count; ++i)

		{

		if (sendArray[i]->iId == aId)

			return i;

		}

	return -1;

	}

void RMessageSendStatesArray::CopyInSelectionL(const CMsvEntrySelection& aSelection)

	{

	ResetAndDestroy();

	TInt count = aSelection.Count();

	while (count--)

		{

		const TMsvId id = aSelection[count];

		CMessageSendStates* msg = CMessageSendStates::NewLC(id);

		User::LeaveIfError(Append(msg));

		CleanupStack::Pop(msg);

		}

	}

CSmcmSendTest* NewSmcmTestLCC(TInt aTestNumber, TInt aExpectedError=KErrNone)

/**

	Constructs and returns CSmsScTest object. 

	Notifies the system agent that the phone is on.

	@return		CSmsScTest*		A pointer to SmsSc test.  

 */

	{

	CSmsTestUtils* testUtils = CSmsTestUtils::NewL(gTest, HasCreatedSmsService?ETuCreateTestDirectories|ETuGoClientSide:ETuMinimalClientSide);

	if (HasCreatedSmsService)

		testUtils->iServiceSettings = CSmsSettings::NewL();

	HasCreatedSmsService = ETrue;

	CleanupStack::PushL(testUtils);

	// System agent fix... this ensures that the correct test script is used by SIM.TSY

	User::LeaveIfError(RProperty::Set(KUidSystemCategory, KUidSASimTsyTestNumberValue, aTestNumber));

//	testUtils->SetSimTsyTestNumberL(aTestNumber);

	testUtils->NotifySaPhoneOffL();

	User::After(5000000); //wait for SmsProt to go to sleep

	DeleteSmsStores(testUtils->FileSession());

	TInt nextTest = 0;

	testUtils->NotifySaPhoneOnL();

	testUtils->WaitForInitializeL();

	return CSmcmSendTest::NewLC(*gAutoTest, *testUtils, KSmsScript, aExpectedError, nextTest);

	}

TBool CSmcmSendTest::CheckWatchersStartedL()

	{

	TBool found = EFalse;

	TFullName fullName;

	TFindThread finder(_L("*"));

	//

	while(finder.Next(fullName) == KErrNone && !found)

		{

		// Open the thread

		RThread thread;

		User::LeaveIfError(thread.Open(fullName));

		// Open the process which owns this thread

		RProcess process;

		const TInt error = thread.Process(process);

		if (error == KErrNone)

			{

			const TFileName fileName(process.FileName());

			if (fileName.Compare(_L("Z:\\System\\Libs\\watcher.exe")) == 0)

				found = ETrue;

			process.Close();

			}

		thread.Close();

		}

	return found;

	}

void CSmcmSendTest::TestReceiveClass2L(TInt aTestNumber, TRequestStatus& aStatus)

	{

	iState = EStateTestReceiveClass2;

	iMessagesReceived = 0;

	SetMessagesToReceiveL(aTestNumber);

	//Set the class 2 folder

	iSmsSettings->SetClass2Folder(KMsvGlobalOutBoxIndexEntryId);

	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

	CSmsAccount* account = CSmsAccount::NewLC();

	account->SaveSettingsL(*iSmsSettings);

	CleanupStack::PopAndDestroy(account);

	iSmsTest.Printf(_L("Waiting to recv %d msgs [test=%d inbox=%d class2=%d]\n"),

		iMessagesToReceive, aTestNumber, KMsvGlobalInBoxIndexEntryId, iSmsSettings->Class2Folder()),

	delete iWatcherStarter;

	iWatcherStarter = NULL;

	TBool watcherRunning = EFalse;

	TRAPD(ignor, watcherRunning = CheckWatchersStartedL());

	if (watcherRunning)

		{

		iSmsTest.Printf(_L("Watchers running.\n"));

		}

	else

		{

		iSmsTest.Printf(_L("Watchers not running. Starting watchers....\n"));

		iWatcherStarter = CTestUtilsWatcherStarter::NewL(CActive::EPriorityHigh);

		}

	iStatus = KRequestPending;

	Queue(aStatus);

	SetActive();

	}

void CSmcmSendTest::TestSendingL(TRequestStatus& aStatus)

	{

	iState = EStateSending;

	TTime now;

	now.HomeTime();

	now += (TTimeIntervalSeconds) 5;

	iSmsTest.DeleteSmsMessagesL(KMsvGlobalOutBoxIndexEntryId);

	iSelection->Reset();

	// Create the test messages specified in the script file and place in the Outbox.

	iSmsTest.Printf(_L("Creating msgs in outbox from script %S\n"), &iScriptFile);

	TBool read = EFalse;

	TRAPD(err, read = iSmsTest.ReadScriptL(iScriptFile, KMsvGlobalOutBoxIndexEntryId, *iSelection, now));

	//iSmsTest.Test()(!err && read);

	LOCAL_CHECKPOINT(iAutoTest, !err && read);

	iSmsTest.Printf(_L("Sending %d messages...\n"), iSelection->Count());

	iSmsTest.DisplayMessagesL(*iSelection);

	iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId);

	delete iOperation;

	iOperation = NULL;

	// Send the message, by copying it to the SMS Service.

	iCurrentMessages.ResetAndDestroy();

	iCurrentMessages.CopyInSelectionL(*iSelection);

	iOperation = MsvEntry().CopyL(*iSelection, iSmsTest.iSmsServiceId, iStatus);

	SetActive();

	Queue(aStatus);

	}

void CSmcmSendTest::TestSchedulingL(TRequestStatus& aStatus)

	{

	iState = EStateScheduling;

	iSmsTest.DeleteSmsMessagesL(KMsvGlobalOutBoxIndexEntryId);

	iSelection->Reset();

	TTimeIntervalSeconds fromNow = 5;

	TTime now;

	now.HomeTime();

	now += fromNow;

	iSmsTest.Printf(_L("Creating msgs in outbox from script %S\n"), &iScriptFile);

	TBool read = EFalse;

	TRAPD(err, read = iSmsTest.ReadScriptL(iScriptFile, KMsvGlobalOutBoxIndexEntryId, *iSelection, now));

	//iSmsTest.Test()(!err && read);

	LOCAL_CHECKPOINT(iAutoTest, !err && read);

	iSmsTest.Printf(_L("Scheduled %d messages...\n"), iSelection->Count());

	iSmsTest.DisplayMessagesL(*iSelection);

	MsvEntry().SetEntryL(KMsvGlobalOutBoxIndexEntryId);

	delete iOperation;

	iOperation = NULL;

	iCurrentMessages.ResetAndDestroy();

	iCurrentMessages.CopyInSelectionL(*iSelection);

	iOperation = Session().TransferCommandL(*iSelection, ESmsMtmCommandScheduleCopy, TPtrC8(), iStatus);

	SetActive();

	Queue(aStatus);

	}

void Test1L()

	{

	CSmcmSendTest* smcmTest = NewSmcmTestLCC(0, KErrServerTerminated);

	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();

	smcmTest->TestSendingL(waiter->iStatus);

	waiter->Start();

	CActiveScheduler::Start();

	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("TestSendingL completed with error"));

	//CleanupStack::PopAndDestroy(waiter);

	//CleanupStack::PopAndDestroy(smcmTest);

	//CleanupStack::PopAndDestroy();

	CleanupStack::PopAndDestroy(3);

	}

void Test2L()

	{

	CSmcmSendTest* smcmTest = NewSmcmTestLCC(0, KErrServerTerminated);

	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();

	smcmTest->TestSchedulingL(waiter->iStatus);

	waiter->Start();

	CActiveScheduler::Start();

	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("TestSchedulingL completed with error"));

	CleanupStack::PopAndDestroy(waiter);

	CleanupStack::PopAndDestroy(smcmTest);

	CleanupStack::PopAndDestroy();

	}

void Test3L()

	{

	CSmcmSendTest* smcmTest = NewSmcmTestLCC(2);

	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();

	smcmTest->TestReceiveClass2L(2, waiter->iStatus);

	waiter->Start();

	CActiveScheduler::Start();

	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("TestReceiveClass2L completed with error"));

	CleanupStack::PopAndDestroy(waiter);

	CleanupStack::PopAndDestroy(smcmTest);

	CleanupStack::PopAndDestroy();

	}

void Test4L()

	{

	CMsvOperationWait* waiter = CMsvOperationWait::NewLC();

	waiter->Start();

	CTestUtilsWatcherStarter* watcherStarter = CTestUtilsWatcherStarter::NewL(waiter->iStatus, 20000000);

	CleanupStack::PushL(watcherStarter);

	CActiveScheduler::Start();

	GLOBAL_CHECKPOINT_COMPARE(waiter->iStatus.Int(), KErrNone, _L("TestReceiveClass2L completed with error"));

	CleanupStack::PopAndDestroy(watcherStarter);

	CleanupStack::PopAndDestroy(waiter);

	}

CSmcmSendTest::~CSmcmSendTest()

	{

	Cancel();

	if (iSmsTest.iMsvSession)

		{

		iSmsTest.iMsvSession->RemoveObserver(*this);

		}

	if (iOperation)

		{

		iOperation->Cancel();

		delete iOperation;

		iOperation = NULL;

		}

	delete iSelection;

	iSelection = NULL;

	if (iTimer)

		{

		iTimer->Cancel();

		delete iTimer;

		iTimer = NULL;

		}

	iCurrentMessages.ResetAndDestroy();

	delete iSmsSettings;

	delete iWatcherStarter;

	}

CSmcmSendTest::CSmcmSendTest(CAutoTest& aAutoTest, CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt aExpectedError, TInt aPriority)

: CActive(aPriority), iState(EStateWaiting), iAutoTest(aAutoTest), iScriptFile(aScriptFile), iSmsTest(aSmsTest), iExpectedError(aExpectedError)

	{

	CActiveScheduler::Add(this);

	}

CSmcmSendTest* CSmcmSendTest::NewLC(CAutoTest& aAutoTest, CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt aExpectedError, TInt aPriority)

	{

	CSmcmSendTest* self = new (ELeave) CSmcmSendTest(aAutoTest, aSmsTest, aScriptFile, aExpectedError, aPriority);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CSmcmSendTest::ConstructL()

	{

	iSmsTest.SetLogToFile();

	iSelection = new (ELeave) CMsvEntrySelection();

	iSmsTest.iMsvSession->AddObserverL(*this);

	iSmsTest.InstantiateClientMtmsL();

	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

	iSmsSettings = CSmsSettings::NewL();

	CSmsAccount* account = CSmsAccount::NewLC();

	account->LoadSettingsL(*iSmsSettings);

	CleanupStack::PopAndDestroy(account);

	}

void CSmcmSendTest::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* /*aArg2*/, TAny* /*aArg3*/)

	{

	CMsvEntrySelection* entries = NULL;

	switch (aEvent)

		{

//		case EMsvEntriesCreated:

		case EMsvEntriesChanged:

		case EMsvEntriesMoved:

			entries = STATIC_CAST(CMsvEntrySelection*, aArg1);

			break;

		default:

			return;

		}

	if (!IsActive())

		return;

	TRequestStatus* status = &iStatus;

	switch (iState)

		{

		case EStateSchedulingThenSend:

		case EStateSending:

			{

			if (aEvent == EMsvEntriesCreated)

				return;

			TInt error = KErrNone;

			iSmsTest.DisplaySendingStatesL(*entries);

			TInt count = entries->Count();

			while (count--)

				{

				const TMsvId id = (*entries)[count];

				const TInt find = iCurrentMessages.Find(id);

				if (find != KErrNotFound)

					{

					CMessageSendStates& messageSendStates = *iCurrentMessages[find];

					CMsvEntry* cEntry = Session().GetEntryL(id);

					CleanupStack::PushL(cEntry);

					const TMsvEntry& entry = cEntry->Entry();

					User::LeaveIfError(messageSendStates.iStates.Append(entry.SendingState()));					

					CleanupStack::PopAndDestroy(cEntry);

					}

				}

			if (iSmsTest.SendingCompleteL(*iSelection, error) && iState == EStateSchedulingThenSend && iStatus == KRequestPending)

				{

				User::RequestComplete(status, error);

				}

			break;

			}

		case EStateTestReceiveClass2:

			if (aEvent != EMsvEntriesChanged)

				return;

			if (!CheckParentOfReceivedMessageL(*entries))

				{

				iSmsTest.Printf(_L("Parent of messages don't match\n"));

				User::RequestComplete(status, KErrGeneral);

				}

			else if (iMessagesReceived >= iMessagesToReceive)

				{

				iSmsTest.Printf(_L("All messages received\n"));

				User::RequestComplete(status, KErrNone);

				}

		default:

			break;

		}

	}

LOCAL_C const TAutoTestCase SmsScTestCases[] =

/**

	Sets up an array of test functions

 */

	{

	{Test1L,_S("Test Sending")},

	{Test2L,_S("Test Schedule Sending")},

	{Test3L,_S("Test Receiving Class2 Messages")},

	{Test4L,_S("Test Start Stop Watchers")}

	};

LOCAL_C void doMainL()

/**

	Constructs sctive scheduler and starts off the tests

 */

	{

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install( scheduler );

	// Copying the config file to the root directory

	RFs fs;

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

	CleanupClosePushL(fs);

	CSmsTestUtils::CopyToSimTsyConfigFileL(fs, KSmsScriptFull);

	DeleteSmsStores(fs);

	CleanupStack::PopAndDestroy(&fs);

	// Open the socket server

	RSocketServ serv;

	RSocket socket;

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

	CleanupClosePushL(serv);