// Copyright (c) 1998-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:
// The purpose of this test harness is to test a fix for INC37442.
// In order to test this, it is necessary to start 2 connections to the same IAP off and then
// cancel one of them. This must be done before the CImConnect has finished connecting.
// 
//


#include "TESTENV.h"
#include <nd_err.h>

#include <imsk.h>

#include <s32mem.h>
#include <s32file.h>
#include <iapprefs.h>
#include "emailtestutils.h"
#include <commdb.h>


LOCAL_D RTest test(_L("IMSK Multiple CImTextServerSessions Test"));

LOCAL_D CTrapCleanup* theCleanup;
LOCAL_D RFs theFs;
LOCAL_D CActiveScheduler* scheduler;
LOCAL_D CEmailTestUtils* testUtils;

// Test Harness Prototypes
LOCAL_C void DoTestThreadWorkL();
static TInt DoTestThreadStart(TAny*);

// Foward declare
class CMsgConnect;
CMsgConnect* gConnect;


// we use a freeserve account;
// this will need to be set up as COMMDB_ID 1 in the cdbv3.dat file
_LIT(KServerAddressConn0, "pop.freeserve.net");
_LIT(KServerAddressConn1, "www.guardian.co.uk");
const TInt KPortNumber = 110;

const TInt KConnectingProgressValue = 2500;
const TInt KConnectionMadeProgressValue = 7000;


// create an active object to connect
class CMsgConnect : public CActive
	{
	public:
		static CMsgConnect* NewLC(TInt aConn);
		~CMsgConnect();

	public:		// CActive
		void RunL();
		void DoCancel();

	public:
		void RequestConnectL();
		void CancelConnectL();
		TInt ConnectProgress();
		TInt GetIAPValue(TUint32 &aIAP);
		TInt GetIAPBearer(TUint32 &aBearer);

	private:
		CMsgConnect(TInt aConn);
		void ConstructL();

	private:
		CImTextServerSession*	iImSocket;
		CImIAPPreferences*		iIAPPreferences;
		TInt					iConn;
	};


CMsgConnect::CMsgConnect(TInt aConn)
:CActive(EPriorityNormal),
 iConn(aConn)
	{
	}

CMsgConnect* CMsgConnect::NewLC(TInt aConn)
	{
	CMsgConnect* self = new (ELeave) CMsgConnect(aConn);
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

void CMsgConnect::ConstructL()
	{
	CActiveScheduler::Add(this); // add to active scheduler
	iImSocket = CImTextServerSession::NewL();
	testUtils->WriteComment(_L("CMsgConnect::ConstructL() OK"));
	}

CMsgConnect::~CMsgConnect()
	{
	Cancel();
	delete iImSocket;
	delete iIAPPreferences;
	}

void CMsgConnect::DoCancel()
	{
	iImSocket->Cancel();
	}

void CMsgConnect::RunL()
	{
	testUtils->WriteComment(_L("CMsgConnect::RunL() start"));

	// if we have cancelled the connection, then the value here will be KErrCancel
	if(iStatus.Int() == KErrCancel)
		{
		testUtils->WriteComment(_L("CMsgConnect - connection cancelled"));
		test.Printf(_L("cancelled"));
		return;
		}

	testUtils->WriteComment(_L("CMsgConnect - connection made"));
	// if we've connected, then say so
	test.Printf(_L("connected"));
	CActiveScheduler::Stop();
	}

void CMsgConnect::RequestConnectL()
	{
	testUtils->WriteComment(_L("CMsgConnect::RequestConnectL() start"));
	test.Next(_L("connecting"));

	iIAPPreferences = CImIAPPreferences::NewLC();		// PUSH		(there is not a NewL() function)
	CleanupStack::Pop(iIAPPreferences);					// POP

	TImIAPChoice iap;
	iap.iIAP = 1;		// COMMDB_ID 1
	iap.iDialogPref = ECommDbDialogPrefDoNotPrompt;
	iIAPPreferences->AddIAPL(iap);

	TBuf<32> serverAddress;
	if(iConn == 0)
		serverAddress = KServerAddressConn0;
	else
		serverAddress = KServerAddressConn1;

	testUtils->WriteComment(_L("CMsgConnect - queuing connect with CImTextServerSesison"));
	iImSocket->QueueConnectL(iStatus, serverAddress, KPortNumber, *iIAPPreferences);
	SetActive();
	}

void CMsgConnect::CancelConnectL()
	{
	testUtils->WriteComment(_L("CMsgConnect cancelling connection"));
	test.Next(_L("Cancel connecting"));
	iImSocket->Disconnect();
	}

TInt CMsgConnect::ConnectProgress()
	{
	return iImSocket->GetConnectionStage();
	}

TInt CMsgConnect::GetIAPValue(TUint32 &aIAP)
	{
	return iImSocket->GetIAPValue(aIAP);
	}

TInt CMsgConnect::GetIAPBearer(TUint32 &aBearer)
	{
	return iImSocket->GetIAPBearer(aBearer);
	}

//

LOCAL_C void Init()
	{
	scheduler = new (ELeave) CActiveScheduler;
	CActiveScheduler::Install(scheduler);

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

	// set up the log file
	testUtils = CEmailTestUtils::NewLC(test);
	testUtils->TestStart(0);
	testUtils->SetLogToFile(ETrue);
	testUtils->WriteComment(_L("This tests a change to CImConnect so that it no longer calls iConn.Stop()"));
	testUtils->WriteComment(_L("in its DoCancel(), but iConn.Close() instead."));
	testUtils->WriteComment(_L("This should not cancel other connections to the internet using that IAP."));
	testUtils->WriteComment(_L("\n"));
	}

LOCAL_C void Closedown()
	{
	testUtils->TestHarnessCompleted();
	CleanupStack::PopAndDestroy(testUtils);

	theFs.Close();
	delete scheduler;
	}
// This tests the change made for "INC040630 - Panic while disconnecting a 
// service". Calling CImTextServerSession::GetConnectionStage with a cancelled
// RConnection caused a panic.
LOCAL_C void TestCancelWithProgress()
	{
	_LIT(KTestThreadName, "CancelWithProgress Test Thread");
	const TInt KMinTestHeapSize = 0x10000;
    const TInt KMaxTestHeapSize = 0x100000;

	TRequestStatus requestStatus;
	RThread testThread;

	gConnect = CMsgConnect::NewLC(0);	// PUSH	

	User::SetJustInTime(EFalse);

	// Set up the conditions which cause the panic. I.e. request a connection
	// then cancel it.
	gConnect->RequestConnectL();

	// Call GetConnectionStage, GetIAPValue, and GetIAPBearer to ensure they
	// return the correct results.
	TUint32 bearer = 1;
	TUint32 iap = 1;
	TInt returnValue;
	
	// Test normal behaviour in this state with a valid but unconnected connection.
	returnValue = gConnect->GetIAPBearer(bearer);
	(*testUtils)(returnValue == KErrNotReady);
	returnValue = gConnect->GetIAPValue(iap);
	(*testUtils)(returnValue == KErrNone || returnValue == KErrNotReady);
	(*testUtils)(iap == 1);
	returnValue = gConnect->ConnectProgress();
	(*testUtils)(returnValue != KErrBadHandle);

	// Cancel the CImTextServerSession 
	gConnect->CancelConnectL();

	// Test after cancel.
	returnValue = gConnect->GetIAPBearer(bearer);
	// GetIAPBearer now returns KErrBadHandle. 
	(*testUtils)(returnValue == KErrBadHandle);

	returnValue = gConnect->GetIAPValue(iap);
	// GetIAPValue now returns KErrBadHandle.
	(*testUtils)(returnValue == KErrBadHandle);

	// CImConnect::Progress now returns KErrBadHandle.
	returnValue = gConnect->ConnectProgress();
	(*testUtils)(returnValue == KErrBadHandle);

	// Create a separate thread to call GetConnectionStage
	testThread.Create(
		KTestThreadName, 
		DoTestThreadStart, // replace
		KDefaultStackSize, 
		KMinTestHeapSize, 
		KMaxTestHeapSize, 
		NULL, 
		EOwnerThread);
	testThread.Logon(requestStatus);

    // Let the thread run
    testThread.Resume();
    User::WaitForRequest(requestStatus);

	// Test whether the thread exitied with a panic.
	TInt result = (testThread.ExitType() == EExitPanic);
	if (result)
		testUtils->WriteComment(
			_L("GetConnectionStage caused panic after Cancel"));
	// Pass or fail the test based on whether the thread stopped because of a
	// panic.
	(*testUtils)(!result);
    testThread.Close();
	User::SetJustInTime(ETrue);

	CleanupStack::PopAndDestroy(gConnect);
	}

LOCAL_C void DoTestThreadWorkL()
    {
    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
    CActiveScheduler::Install(scheduler);
    CleanupStack::PushL(scheduler);
	// ConnectProgress calls GetConnectionStage in CImTextServerSession.
	gConnect->ConnectProgress();
	CleanupStack::PopAndDestroy(scheduler);
	}

static TInt DoTestThreadStart(TAny*)
    {
    // Entry function for the child thread which is created then killed.
    CTrapCleanup* cleanup = CTrapCleanup::New();
    test(cleanup != NULL);

    TRAPD(ret, DoTestThreadWorkL());
    delete cleanup;
    return 0;
    }


//

LOCAL_C void doMainL()
	{
	Init();

	TInt testNo = 1;
	testUtils->TestStart(testNo);
	testUtils->WriteComment(
		_L("Testing calls to CImTextServerSession Cancel then GetConnectionStage"));
	TestCancelWithProgress();
	testUtils->TestFinish(testNo);
	testNo += 1;

	CMsgConnect* connect1 = CMsgConnect::NewLC(0);	// PUSH
	CMsgConnect* connect2 = CMsgConnect::NewLC(1);	// PUSH

	testUtils->WriteComment(_L("1st connect object connecting"));
	connect1->RequestConnectL();
	// wait a while before starting the next connection
	testUtils->WriteComment(_L("waiting a little while before starting the 2nd connection"));
	User::After(1000000);

	testUtils->WriteComment(_L("2nd connect object connecting"));
	connect2->RequestConnectL();

	// we wait until the connect2 is actually connecting,
	// this is when the progress value = 2500
	testUtils->WriteComment(_L("we should only cancel the connection when it is connecting"));

	for(TInt a = 0; a < 100; a++)
		{	
		// if connect2 has got so far as connecting, then we should fail the test because
		// this test relies on us cancelling the connection when it is connecting
		if(connect2->ConnectProgress() == KConnectionMadeProgressValue)
			{
			testUtils->WriteComment(_L("connection made before we can cancel it"));
			testUtils->WriteComment(_L("TEST FAILED"));
			CleanupStack::PopAndDestroy(2);			// connect2 & connect1
			Closedown();
			return;
			}

		// note that the connect progress could have skipped past the connecting value, whilst we
		// are waiting for the 1second to pass, so if the progress is higher than the connecting
		// value, then we should cancel it as well
		if(connect2->ConnectProgress() > KConnectingProgressValue)
			{
			testUtils->WriteComment(_L("cancelling the 2nd connection"));
			connect2->CancelConnectL();
			break;
			}
		
		User::After(1000000);
		}
	
	// wait until the 1st one has connected correctly
	testUtils->WriteComment(_L("wait for the 1st connection object to connect"));
	CActiveScheduler::Start();

	// cancel the connection of the connection that is up and running
	testUtils->WriteComment(_L("cancel the 1st connection object"));
	connect1->CancelConnectL();

	CleanupStack::PopAndDestroy(2);					// connect2 & connect1
	Closedown();
	}


GLDEF_C TInt E32Main()
	{
	test.SetLogged(ETrue);
	test.Title();
	test.Start(_L("Testing Multiple connections on one IAP using CImTextServerSession"));
	__UHEAP_MARK;

	theCleanup=CTrapCleanup::New();
	test (theCleanup!=NULL);
	TRAPD(ret,doMainL());
	test (ret==KErrNone);
	delete theCleanup;

	__UHEAP_MARKEND;
	test.End();
	return 0;
	}