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

// Contains the implementation of the test cases that predominately use the dummy nif

// as the default interface.

//

//

/**

 @file

*/

#include "TE_RConnectionDummyNifTestSteps.h"

// for the null agt progress values

#include <nullagtprog.h>

#include <connectprog.h>

#include "TE_RConnPanicStep.cpp"

#include <networking/pppprog.h>

#include <nifman.h>

#include <inet6err.h>

#include <dummynifvar.h>

#include <comms-infras/esocktestutils.h>

#include <es_panic.h>

#include <e32cons.h>

#include <comms-infras/es_commsdataobject.h>

#include <commdbconnpref.h>

#include <commsdattypeinfov1_1.h>

#include <comms-infras/connectionqueryset.h>

#include <csdprog.h>

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ESockTestTERCnct, "ESockTestTERCnct");

#endif

using namespace ESock;

TE_RConnectionTest1::~TE_RConnectionTest1()

{

}

// creates a connection and destroys it again

enum TVerdict TE_RConnectionTest1::doTestStepL()

{

	TInt err;

	RConnection conn;

	RSocketServ ss;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	INFO_PRINTF1(_L("TEST ABOUT TOO COMPLETE..."));

	return TestStepResult();

} // TE_RConnectionTest1

/**

Testing closing a connection during its startup.

C++ constructor

*/

TE_RConnectionTest1b::~TE_RConnectionTest1b()

	{

	}

class MProgressObserverTest1b

	{

public:

	virtual void MPOStageReached(TInt aStage, TInt aError) = 0;

	};

class CProgressWatcherTest1b : public CActive

	{

public:

	static CProgressWatcherTest1b* NewL(RConnection& aConnection, MProgressObserverTest1b& aObserver);

	virtual ~CProgressWatcherTest1b();

	const TNifProgressBuf& Progress() const { return iNifProgressBuf; }

protected:

	virtual void DoCancel();

	virtual void RunL();

private:

	CProgressWatcherTest1b(RConnection& aConnection, MProgressObserverTest1b& aObserver);

	void ConstructL();

	void RequestProgressNotification();

private:

	MProgressObserverTest1b& iObserver;

	RConnection& iConnection;

	TNifProgressBuf iNifProgressBuf;

	};

CProgressWatcherTest1b* CProgressWatcherTest1b::NewL(RConnection& aConnection, MProgressObserverTest1b& aObserver)

	{

	CProgressWatcherTest1b* self = new(ELeave) CProgressWatcherTest1b(aConnection, aObserver);

	return self;

	}

CProgressWatcherTest1b::CProgressWatcherTest1b(RConnection& aConnection, MProgressObserverTest1b& aObserver)

: CActive(CActive::EPriorityStandard), iObserver(aObserver), iConnection(aConnection)

	{

	CActiveScheduler::Add(this);

	RequestProgressNotification();

	}

CProgressWatcherTest1b::~CProgressWatcherTest1b()

	{

	Cancel();

	}

void CProgressWatcherTest1b::DoCancel()

	{

	iConnection.CancelProgressNotification();

	}

void CProgressWatcherTest1b::RunL()

	{

	if(iStatus == KErrNone)

		{

		iObserver.MPOStageReached(iNifProgressBuf().iStage, iNifProgressBuf().iError);

		}

	RequestProgressNotification();

	}

void CProgressWatcherTest1b::RequestProgressNotification()

	{

	if (!IsActive())

		{

		iConnection.ProgressNotification(iNifProgressBuf,iStatus);

		SetActive();

		}

	}

class CConnectionTest1b : public CActive

	{

public:

	static CConnectionTest1b* NewL(MProgressObserverTest1b& aObserver, CTestExecuteLogger& aLogger);

	virtual ~CConnectionTest1b();

	void Start();

	void StopProgressObservation();

	void GetConnectionInfoL(TConnectionInfo& aInfo);

protected:

	virtual void DoCancel();

	virtual void RunL();

private:

	CConnectionTest1b(CTestExecuteLogger& aLogger);

	void ConstructL(MProgressObserverTest1b& aObserver);

	inline CTestExecuteLogger& Logger() {return iLogger;};

private:

	CTestExecuteLogger& iLogger;

	RSocketServ iSocketServ;

	RConnection iConnection;

	CProgressWatcherTest1b* iProgressWatcher;

	};

CConnectionTest1b* CConnectionTest1b::NewL(MProgressObserverTest1b& aObserver, CTestExecuteLogger& aLogger)

	{

	CConnectionTest1b* self = new(ELeave) CConnectionTest1b(aLogger);

	CleanupStack::PushL(self);

	self->ConstructL(aObserver);

	CleanupStack::Pop(self);

	return self;

	}

CConnectionTest1b::CConnectionTest1b(CTestExecuteLogger& aLogger)

: CActive(CActive::EPriorityStandard), iLogger(aLogger)

	{

	CActiveScheduler::Add(this);

	}

void CConnectionTest1b::ConstructL(MProgressObserverTest1b& aObserver)

	{

	INFO_PRINTF1(_L("Opening Connection"));

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

	User::LeaveIfError(iConnection.Open(iSocketServ));

	iProgressWatcher = CProgressWatcherTest1b::NewL(iConnection, aObserver);

	}

CConnectionTest1b::~CConnectionTest1b()

	{

	if(iConnection.SubSessionHandle() && iProgressWatcher)

		{

		INFO_PRINTF2(_L("Closing Connection at Stage %d"), iProgressWatcher->Progress()().iStage);

		}

	Cancel();

	delete iProgressWatcher;

	iProgressWatcher = NULL;

	iConnection.Close();

	iSocketServ.Close();

	}

void CConnectionTest1b::Start()

	{

	INFO_PRINTF1(_L("Starting Connection"));

	iConnection.Start(iStatus);

	SetActive();

	}

void CConnectionTest1b::StopProgressObservation()

	{

	delete iProgressWatcher;

	iProgressWatcher = NULL;

	}

void CConnectionTest1b::DoCancel()

	{

	StopProgressObservation();

	}

void CConnectionTest1b::RunL()

	{

	}

class CTest1b : public CActive, public MProgressObserverTest1b

	{

public:

	static CTest1b* NewLC(CTestExecuteLogger& aLogger);

	virtual ~CTest1b();

	virtual void MPOStageReached(TInt aStage, TInt aError);

protected:

	virtual void DoCancel();

	virtual void RunL();

	virtual TInt RunError(TInt aError);

private:

	CTest1b(CTestExecuteLogger& aLogger);

	void ConstructL();

	inline CTestExecuteLogger& Logger() {return iLogger;};

private:

	CTestExecuteLogger& iLogger;

	CConnectionTest1b* iConnection;

	TInt iCancelAtStage;

	TInt iCurrentStage;

	TBool iLaststage;

	};

CTest1b* CTest1b::NewLC(CTestExecuteLogger& aLogger)

	{

	CTest1b* self = new(ELeave) CTest1b(aLogger);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CTest1b::CTest1b(CTestExecuteLogger& aLogger)

: CActive(CActive::EPriorityStandard), iLogger(aLogger)

	{

	CActiveScheduler::Add(this);

	}

void CTest1b::ConstructL()

	{

	INFO_PRINTF2(_L("Waiting for progress #%d"), iCancelAtStage);

	iConnection = CConnectionTest1b::NewL(*this, Logger());

	iConnection->Start();

	}

CTest1b::~CTest1b()

	{

	Cancel();

	delete iConnection;

	}

void CTest1b::MPOStageReached(TInt aStage, TInt aError)

	{

	INFO_PRINTF3(_L("Progress received - stage: %d, error: %d"), aStage, aError);

	iCurrentStage++;

	iLaststage = (aStage==0) & (aError==0);

	if(iCancelAtStage <= iCurrentStage || iLaststage)

		{

		SetActive();

		TRequestStatus* pS = &iStatus;

		User::RequestComplete(pS, aError);

		}

	}

void CTest1b::DoCancel()

	{

	RDebug::Print(_L("\nCTest::DoCancel"));

	delete iConnection;

	iConnection = NULL;

	}

void CTest1b::RunL()

	{

	delete iConnection;

	iConnection = NULL;

	if (iLaststage)

		{

		INFO_PRINTF1(_L("Completed test successfully"));

		CActiveScheduler::Stop();

		}

	else

		{

		iCancelAtStage++;

		INFO_PRINTF2(_L("Waiting for progress #%d"), iCancelAtStage);

		iConnection = CConnectionTest1b::NewL(*this, Logger());

		iCurrentStage = 1;

		iConnection->Start();

		}

	}

TInt CTest1b::RunError(TInt aError)

	{

	INFO_PRINTF3(_L("Error %d while waiting for progress #%d"), aError, iCancelAtStage);

	CActiveScheduler::Stop();

	return KErrNone;

	}

LOCAL_C void DoTestL(CTestExecuteLogger& aLogger)

	{

	CTest1b* test = CTest1b::NewLC(aLogger);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(test);

	}

enum TVerdict TE_RConnectionTest1b::doTestStepL(void)

	{

	__UHEAP_MARK;

	CTrapCleanup* trapCleanup = CTrapCleanup::New();

	TRAPD(r, DoTestL(Logger()));

	RDebug::Print(_L("TE_RConnectionTest1b::DoTestL returned error %d"), r);

	delete trapCleanup;

	__UHEAP_MARKEND;

	return TestStepResult();

	}

TE_RConnectionTest2::~TE_RConnectionTest2()

{

}

// creates a connection and destroy it again - use the synchronous start

enum TVerdict TE_RConnectionTest2::doTestStepL(void)

{

	TInt err;

	RConnection conn;

	RSocketServ ss;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnectionSynchronous(conn);

	TESTEL(KErrNone == err, err);

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest2

TE_RConnectionTest3::~TE_RConnectionTest3()

{

}

// Create a connection using database overrides and then destroy it

enum TVerdict TE_RConnectionTest3::doTestStepL(void)

{

	TInt err;

	RConnection conn;

	RSocketServ ss;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnectionWithOverrides(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest3

TE_RConnectionTest4::~TE_RConnectionTest4()

{

}

// Create a connection using database overrides and then destroy it - use the synchronous start

enum TVerdict TE_RConnectionTest4::doTestStepL(void)

{

	TInt err;

	RConnection conn;

	RSocketServ ss;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnectionWithOverridesSynchronous(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest4

TE_RConnectionTest5::~TE_RConnectionTest5()

{

}

// Implicitly create a single connection using SendTo()

enum TVerdict TE_RConnectionTest5::doTestStepL(void)

{

	TInt err;

	RSocketServ ss;

	RSocket sock;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenUdpSocketL(sock, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	err = TestUdpDataPathL(sock, iDummyNifSendAddr); // this will use SendTo()

	TESTEL(KErrNone == err, err);

	DestroyUdpSocket(sock);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest5

TE_RConnectionTest6::~TE_RConnectionTest6()

{

}

// Explicitly associate a UDP socket to an existing connection

enum TVerdict TE_RConnectionTest6::doTestStepL(void)

{

	TInt err;

	RSocketServ ss;

	RConnection conn;

	RSocket sock;

	err = OpenSocketServer(ss);