// Copyright (c) 2006-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 new test cases that use Dummy Nif

// added to improve test coverage

// 

//

//

/**

 @file

*/

#include "TE_RConnectionNewDummyTests.h"

#include <cs_subconevents.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_ESockTestTERCnND, "ESockTestTERCnND");

#endif

TE_RConnectionTest800::~TE_RConnectionTest800()

	{

	}

enum TVerdict TE_RConnectionTest800::doTestStepL(void)

// Ensure that Close() does not pull down the interface when there are sockets associated with it

	{

	TInt err;

	RSocketServ ss;

	RConnection conn;

	RSocket sock;

	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);

	err = OpenUdpSocketExplicitL(sock, ss, conn);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

	TESTEL(KErrNone == err, err);

	CleanupStack::PopAndDestroy(&sock);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&ss);

	return TestStepResult();

	} // TE_RConnectionTest800

TE_RConnectionTest801::~TE_RConnectionTest801()

	{

	}

enum TVerdict TE_RConnectionTest801::doTestStepL(void)

/*

 * Ensure that if stop is called on a non existant sub connection that the server deals with this

 */

	{

	SetTestStepResult (EFail);

	TInt err;

	RSocketServ ss;

	RConnection conn;

	RSocket sock;

	// open socket server

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	// open connection

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// start connection

	err = StartConnectionWithOverrides(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	// open udp socket

	err = OpenUdpSocketExplicitL(sock, ss, conn);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	// send data using udp socket

	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

	TESTEL(KErrNone == err, err);

	// stop subconnection with invalid sub connection ID

	err = conn.Stop(555, RConnection::EStopNormal);

	if(err == KErrNotReady)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(&sock);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&ss);

	return TestStepResult();

	} // TE_RConnectionTest801

TE_RConnectionTest802::~TE_RConnectionTest802()

	{

	}

enum TVerdict TE_RConnectionTest802::doTestStepL(void)

/*

 * Make a call to Cancel a DataTransferredRequest, then call an actual DataTransferredRequest

 * verify that the previous cancel doesn't affect the new DataTransferredRequest call

 */

	{

	TInt err;

	RSocketServ ss;

	RConnection conn;

	RSocket sock;

	SetTestStepResult (EFail);

	// Open Socket Server

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	// Open sub connection

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// start connection

	err = StartConnectionWithOverrides(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	// open udp socket

	err = OpenUdpSocketExplicitL(sock, ss, conn);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	// send data using socket

	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

	TESTEL(KErrNone == err, err);

	TPckg<TUint> down(0);

	TPckg<TUint> up(0);

	TRequestStatus transferredStatus;

	// cancel data transferred call

	conn.DataTransferredCancel();

	// issue data transferred call

	conn.DataTransferredRequest( up, down, transferredStatus);

	User::WaitForRequest(transferredStatus);

	TESTEL(KErrNone == transferredStatus.Int(), transferredStatus.Int());

	// verify that uplink buffer has not been corrupted

	TInt uplink = 0;

	uplink = up();

	if(uplink >= 0)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(&sock);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&ss);

	return TestStepResult();

	} // TE_RConnectionTest802

TE_RConnectionTest803::~TE_RConnectionTest803()

	{

	}

enum TVerdict TE_RConnectionTest803::doTestStepL(void)

/*

 * Make a call to DataTransferredRequest, Connection has not been started

 */

	{

	TInt err;

	RSocketServ ss;

	RConnection conn;

	SetTestStepResult (EFail);

	// open socket server

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	// open connection

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	TPckg<TUint> down(0);

	TPckg<TUint> up(0);

	TRequestStatus transferredStatus;

	// issue data transferred request, conn has NOT been started

	conn.DataTransferredRequest( up, down, transferredStatus);

	User::WaitForRequest(transferredStatus);

	if(KErrNotReady == transferredStatus.Int())

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&ss);

	return TestStepResult();

	} // TE_RConnectionTest803

TE_RConnectionTest804::~TE_RConnectionTest804()

	{

	}

enum TVerdict TE_RConnectionTest804::doTestStepL(void)

/*

 * make a call to DataTransferredRequest on a subconnection ID that does not exist

 */

	{

	TInt err;

	RSocketServ ss;

	RConnection conn;

	RSocket sock;

	// open socket server

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	// open connection

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// start connection

	err = StartConnectionWithOverrides(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	// open UDP socket

	err = OpenUdpSocketExplicitL(sock, ss, conn);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	// send data with socket

	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

	TESTEL(KErrNone == err, err);

	TPckg<TUint> down(0);

	TPckg<TUint> up(0);

	TRequestStatus transferredStatus;

	// make a call to data transferred request on subconnection with invalid sub conn ID

	const TUint KInvalidSubConn = 555;

	conn.DataTransferredRequest(KInvalidSubConn, up, down, transferredStatus);

	User::WaitForRequest(transferredStatus);

	TESTEL(KErrArgument == transferredStatus.Int(), transferredStatus.Int());

	CleanupStack::PopAndDestroy(&sock);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&ss);

	return TestStepResult();

	} // TE_RConnectionTest804

TE_RConnectionTest805::~TE_RConnectionTest805()

	{

	}

enum TVerdict TE_RConnectionTest805::doTestStepL(void)

/*

 * Make a call to DataSentNotificationRequest with athreshold being one hundred bytes, threshold is reached

 */

	{

	TInt err;

	RSocketServ ss;

	RConnection conn;

	RSocket sock;

	SetTestStepResult (EFail);

	// open socket server

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	// open connection

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// start connection

	err = StartConnectionWithOverrides(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	//	Open UDO socket

	err = OpenUdpSocketExplicitL(sock, ss, conn);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	// make DataSentNotificationRequest after 100 bytes has been transferred

	const TUint KHundredBytes = 100;

	TPckg< TUint > uplinkPkg(0);

	TRequestStatus dataSentStatus;

	conn.DataSentNotificationRequest(KHundredBytes, uplinkPkg, dataSentStatus);

	// send over 100 bytes using udp socket

	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

	TESTEL(KErrNone == err, err);

	// Make sure uplinkPkg has not been corrupted

	User::WaitForRequest(dataSentStatus);

	TInt uplinkResult = 0;

	uplinkResult = uplinkPkg();

	if(uplinkResult >= 0)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(&sock);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&ss);

	return TestStepResult();

	} // TE_RConnectionTest805

TE_RConnectionTest806::~TE_RConnectionTest806()

	{

	}

enum TVerdict TE_RConnectionTest806::doTestStepL(void)

/*

 * Make a call to DataSentNotificationRequest with athreshold being one Thousand bytes

 * Threshold is NOT reached

 */

	{

	TInt err;

	RSocketServ ss;

	RConnection conn;

	RSocket sock;

	SetTestStepResult (EFail);

	// open socket server

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	// open connection

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// start connection

	err = StartConnectionWithOverrides(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	// open UDP Socket

	err = OpenUdpSocketExplicitL(sock, ss, conn);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	// make DataSentNotificationRequest after 1000 bytes has been transferred

	const TUint KThousandBytes = 1000;

	TPckg< TUint > uplinkPkg(0);

	TRequestStatus dataSentStatus;

	conn.DataSentNotificationRequest(KThousandBytes, uplinkPkg, dataSentStatus);

	// send less than 1000 bytes

	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

	TESTEL(KErrNone == err, err);

	// Should not have completed - wait a short period and check.

	const TInt KPausePeriod = 2;

	User::After(KPausePeriod * 1000000);

	TESTEL(KRequestPending == dataSentStatus.Int(), dataSentStatus.Int());

	// Stop connection and verify data monitoring completion code is KErrCancel from the Stop()

	conn.Stop();

	User::WaitForRequest(dataSentStatus);

	TESTEL(KErrCancel == dataSentStatus.Int(), dataSentStatus.Int());

	// verify uplink result is unchanged

	TUint uplinkResult = uplinkPkg();

	if(uplinkResult == 0)

		{

		SetTestStepResult(EPass);

		}

	CleanupStack::PopAndDestroy(&sock);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&ss);

	return TestStepResult();

	} // TE_RConnectionTest806

TE_RConnectionTest807::~TE_RConnectionTest807()

	{

	}

enum TVerdict TE_RConnectionTest807::doTestStepL(void)

/*

 * Make a call to DataSentNotificationRequest with athreshold being one Thousand bytes

 * Threshold is reached, invalid subconnection ID

 */	{

	TInt err;

	RSocketServ ss;

	RConnection conn;

	RSocket sock;

	// open socket server

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	// open connection

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// start connection

	err = StartConnectionWithOverrides(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	// open UDP socket

	err = OpenUdpSocketExplicitL(sock, ss, conn);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	 // make DataSentNotificationRequest on subconnection after 100 bytes has been transferred, Sub conn ID is not valid

	const TUint KInvalidSubConnID = 555;

	const TUint KHundredBytes = 100;

	TPckg< TUint > uplinkPkg(0);

	TRequestStatus dataSentStatus;

	conn.DataSentNotificationRequest( KInvalidSubConnID, KHundredBytes, uplinkPkg, dataSentStatus );

	// send data, threshold of 100 is reached

	err = TestUdpDataPathL(sock, iDummyNifSendAddr, 1000);

	TESTEL(KErrNone == err, err);

	// verify call returns

	User::WaitForRequest(dataSentStatus);

	TESTEL(KErrArgument == dataSentStatus.Int(), dataSentStatus.Int());

	CleanupStack::PopAndDestroy(&sock);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&ss);

	return TestStepResult();

	} // TE_RConnectionTest807

TE_RConnectionTest808::~TE_RConnectionTest808()

	{

	}

enum TVerdict TE_RConnectionTest808::doTestStepL(void)

/*

 * Make a call to DataSentNotificationRequest with athreshold being one Thousand bytes

 * Threshold is reached, using VALID subconnection ID

 */

	{

	TInt err;

	RSocketServ ss;

	RConnection conn;

	RSocket sock;

	SetTestStepResult(EPass);

	// open socket server

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	// open connection

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// start connection

	err = StartConnectionWithOverrides(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	// open UDP socket

	err = OpenUdpSocketExplicitL(sock, ss, conn);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	const TUint KHundredBytes = 100;