// 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 test cases testing CMM functionality of RConnection.

// 

//

/**

 @file

*/

#include "TE_RConnectionCMM.h"

#include <ss_std.h>

#include <comms-infras/nifprvar.h>

#include <nifman.h>

#include <inet6err.h>

#include <in6_opt.h>

/**

 * Subconnection Management API extensions

 * 

 * - 400 EnumerateSubConnections(TUint& aCount);

 * - 400 GetSubConnectionInfo(TDes8& aSubConnectionInfo);

 * - 401 GetSubConnectionInfo(TUint aIndex, TDes8& aSubConnectionInfo);

 * - 402 AllSubConnectionNotification(TSubConnectionNotificationBuf& aSubConnectionEvent, TRequestStatus& aStatus);

 * - 403 CancelAllSubConnectionNotification();

 * - 404 DataTransferredRequest(TPckg<TUint>& aUplinkVolume, TPckg<TUint>& aDownlinkVolume, TRequestStatus& aStatus);

 * - 405 DataTransferredRequest(TSubConnectionUniqueId aSubConnectionUniqueId, TPckg<TUint>& aUplinkVolume, TPckg<TUint>& aDownlinkVolume, TRequestStatus& aStatus);

 * - 406 DataTransferredCancel();

 * - 407 DataTransferredCancel(TSubConnectionUniqueId aSubConnectionUniqueId);

 * - 408 DataSentNotificationRequest(TUint aThreshold, TPckg<TUint>& aUplinkVolume, TRequestStatus& aStatus);

 * - 419 DataSentNotificationRequest(TSubConnectionUniqueId aSubConnectionUniqueId, TUint aThreshold, TPckg<TUint>& aUplinkVolume, TRequestStatus& aStatus);

 * - 410 DataSentNotificationCancel();

 * - 411 DataSentNotificationCancel(TSubConnectionUniqueId aSubConnectionUniqueId);

 * - 412 DataReceivedNotificationRequest(TUint aThreshold, TPckg<TUint>& aDownlinkVolume, TRequestStatus& aStatus);

 * - 413 DataReceivedNotificationRequest(TSubConnectionUniqueId aSubConnectionUniqueId, TUint aThreshold, TPckg<TUint>& aDownlinkVolume, TRequestStatus& aStatus);

 * - 414 DataReceivedNotificationCancel();

 * - 415 DataReceivedNotificationCancel(TSubConnectionUniqueId aSubConnectionUniqueId);

 * - 416 IsConnectionActiveRequest(TUint aSecs, TPckg<TBool>& aState, TRequestStatus& aStatus);

 * - 417 IsConnectionActiveCancel();

 * - 418 IsSubConnectionActiveRequest(TSubConnectionUniqueId aSubConnectionUniqueId, TUint aSecs, TPckg<TBool>& aState, TRequestStatus& aStatus);

 * - 419 IsSubConnectionActiveCancel(TSubConnectionUniqueId aSubConnectionUniqueId);

 * - 419b IsSubConnectionActiveCancel(TSubConnectionUniqueId aSubConnectionUniqueId); [Connection Stopped Before Cancel]

 * - 420 Create two connections and enumerate

 * - 421 Multiple outstanding requests on a single interface.

 * - 422 Test erroring of sockets following an EStopNormal

 * - 423 Test erroring of sockets following an EStopAuthoritative

 * - 424 Test stopping subconnections when using the Nifman compatibility layer.

 * - 425 Test DataTransferredRequest() when multiple interfaces are dealing with requests 

 * - 426 Test DataSentNotificationRequest() when multiple interfaces are dealing with requests

 * - 427 Test DataReceivedNotificationRequest() when multiple interfaces are dealing with requests 

 * - 428 Explicitly create a single test NIF connection (using commdb settings) enumerate subconnections and get subconnection info (both with and without subconnection ID).

 * - 429 AllSubConnectionNotification test using the test NIF.

 * - 430 Test of cancellation of AllSubConnectionNotification when using the test NIF

 * - 431 Test of DataTransferredRequest() when using the test NIF.

 * - 432 Test of DataTransferredRequest() for subconnection when using test NIF.

 * - 433 Test of DataSentNotification() request when using the test NIF.

 * - 434 Test of DataSentNotification() request for subconnections when using the test NIF.

 * - 435 Test of DataSentNotification() cancellation when using the test NIF.

 * - 436 Test of DataSentNotification cancellation for subconnections when using the test NIF.

 * - 437 Test of DataReceivedNotification when using the test NIF.

 * - 438 Test of DataReceivedNotification() request for subconnections when using the test NIF.

 * - 439 Test of DataReceivedNotification() cancellation when using the test NIF.

 * - 440 Test of DataReceivedNotification() cancellation for subconnections when using the test NIF.

 * - 441 Test DataTransferredRequest for subconnection with primary and secondary contexts present

 * - 442 Test DataTransferred Request() for subconnection (primary context) with a secondary context present.

 * - 443 Test DataTransferredRequest() for subconnection (secondary context) with another secondary context present.

 * - 444 Test DataTransferredRequest() for complete connection when multiple subconnections are active.

 * - 445 Test for DataTransferred Request on one context then another

 * - 446 Test DataSentNotification() for a secondary context while the primary is also active.

 * - 447 Test DataSentNotification() for primary context while a secondary is also active.

 * - 448 Test DataSentNotification() for complete connection while multiple subconnections are active and passing traffic

 * - 449 Test for DataSentNotification on one context then another

 * - 450 Tests for multiple parallel DataSentNotification requests and cancellation with multiple contexts

 * - 451 Test DataReceivedNotification() for a secondary context while the primary is also active.

 * - 452 Test DataReceivedNotification() for primary context while a secondary is also active.

 * - 453 Test DataReceivedNotification() for complete connection while multiple subconnections are active and passing traffic

 * - 454 Test for DataReceivedNotification on one context then another

 * - 455 Tests for multiple parallel DataReceivedNotification requests and cancellation with multiple contexts

 * - 456 AllSubConnectionNotification test with multiple subconnections.

 * - 457 Simple test with two interfaces - one which supports the new M classes one which doesn't. Try out DataTransferredRequest for each.

 * - 458 Use DataSentNotification while two interfaces (one supporting the M class interface and one not) are active - make request on NIF which does support the extra interface.

 * - 459 Use DataSentNotification while two interfaces (one supporting the M class interface and one not) are active - make request on NIF which does support the extra interface.

 * - 460 Use DataReceivedNotification while two interfaces (one supporting the M class inteface and one not) are active - make request on NIF not supporting extra interface.

 * - 461 Use DataReceivedNotification while two interfaces (one supporting the M class inteface and one not) are active - make request on NIF which does support the interface.

 * - 462 Simple test with two interfaces neither of which support the extended management interface. Try out DataTransferredRequest for  each.

 * - 463 Two interfaces neither of which support extended management interface. Parallel use of DataTransferredRequest

 * - 464 Use DataSentNotification while two interfaces are active (neither of which supports the extended management interface). - make request on first interface created

 * - 465 Use DataSentNotification while two interfaces are active (neither of which supports the extended management interface). - make request on second interface created.

 * - 466 Use DataReceivedNotification while two interfaces are active (neither of which supports the extended management interface). - make request on first interface created.

 * - 467 Use DataReceivedNotification while two interfaces are active (neither of which supports the extended management interface). - make request on second interface created.

 * - 468 Use AllSubConnectionNotification while two interfaces are active (neither of which supports the extended management interface).

 */

#define E_DELAY 1000000

#define E_1SEC  1

#define E_10SEC 10

#define NUM_OF_REPETITIONS 10

enum TVerdict TE_RConnectionTest400::doTestStepL(void)

{

/**

 * Test 400

 * Creates connection and enumerates

 * Tests for EnumerateSubConnections() & GetSubConnectionInfo();

 * @return enum TVerdict Indicates status of test run. See INFO_PRINTF1.h for possible values

 */

	TInt err;

	// Open socket server

	RSocketServ ss;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	// Open connection

	RConnection conn;

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// Start DUMMYNIF asynchronously

	// Note: Could be any other NIFs 

	TRequestStatus status;

	TCommDbConnPref prefs;

	StartConnectionWithOverridesAsynchronous(conn, prefs, iDummyNifIap, status);

	// while it's starting, check that EnumerateSubConnections returns error 

	// DEF021400

	TUint subconnectionCount;

	err = conn.EnumerateSubConnections(subconnectionCount);

	TESTEL(KErrNotReady == err, err);

	User::WaitForRequest(status);

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

	TUint connectionCount;

	err = conn.EnumerateConnections(connectionCount);

	TESTEL(KErrNone == err, err);

	// check connection counter

	TESTEL(1 == connectionCount, KErrGeneral);

	// TConnectionInfo version 1

	TPckgBuf<TConnectionInfo> connectionInfoV1;

	err = conn.GetConnectionInfo(1, connectionInfoV1);

	TESTEL(KErrNone == err, KErrGeneral);

	TPckgBuf<TConnectionInfoV2> connectionInfo;

	// try wrong argument - 0 

	err = conn.GetConnectionInfo(0, connectionInfo);

	TESTEL(KErrArgument == err, err);

	// get connection info

	err = conn.GetConnectionInfo(1, connectionInfo);

	TESTEL(KErrNone == err, err);

	err = conn.EnumerateSubConnections(subconnectionCount);

	TESTEL(KErrNone == err, err);

	TESTEL(2 == subconnectionCount, subconnectionCount);

	TPckgBuf<TSubConnectionInfo> subconnectionInfo;

	// for entire connection (index 0)

	err = conn.GetSubConnectionInfo(0, subconnectionInfo);

	TESTEL(KErrNone == err, err);

	// check unique ID

	// unique ID must be 0 

	TSubConnectionUniqueId uniqueID = subconnectionInfo().iSubConnectionUniqueId;

	TESTEL(uniqueID == 0, KErrGeneral);

	// for subconnection (index 1)

	// for phase 1 we can have only one subconnection 

	err = conn.GetSubConnectionInfo(1, subconnectionInfo);

	TESTEL(KErrNone == err, err);

	// check unique ID

	// for phase 1 subconnection ID is 1 (...)

	uniqueID = subconnectionInfo().iSubConnectionUniqueId;

	TESTEL(uniqueID != 0, KErrGeneral);

	TUint count(0);

	// check number of connections before start

	err = conn.EnumerateConnections( count );

	TESTEL(KErrNone == err, err);

	TESTEL(1 == count, count);

	// stop connection

	conn.Stop();

	// check number of connections after stop

	err = conn.EnumerateConnections( count );

	TESTEL(KErrNone == err, err);

	TESTEL(0 == count, count);

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest400

enum TVerdict TE_RConnectionTest401::doTestStepL(void)

{

/**

 * Test 401

 * Get subconnection info

 * Test GetSubConnectionInfo(TSubConnectionInfo& aSubConnectionIfo)

 * @return enum TVerdict Indicates status of test run. See INFO_PRINTF1.h for possible values

 */

	TInt err;

	RSocketServ ss;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	RConnection conn;

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// start DUMMYNIF

	err = StartConnectionWithOverrides(conn, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	TUint connectionCount;

	err = conn.EnumerateConnections(connectionCount);

	TESTEL(KErrNone == err, err);

	// 1 connection

	TESTEL(1 == connectionCount, connectionCount);

	TPckgBuf<TConnectionInfoV2> connectionInfo;

	err = conn.GetConnectionInfo(1, connectionInfo);

	TESTEL(KErrNone == err, err);

	TUint subconnectionCount;

	err = conn.EnumerateSubConnections(subconnectionCount);

	TESTEL(KErrNone == err, err);

	TESTEL(2 == subconnectionCount, subconnectionCount);

	TPckgBuf<TSubConnectionInfo> subconnectionInfo;

	// Call GetSubConnectionInfo(TUint aIndex, TSubConnectionInfo& aSubConnectionIfo)

	// to get Unique ID

	err = conn.GetSubConnectionInfo(1, subconnectionInfo);

	TESTEL(KErrNone == err, err);

	// Check unique ID

	TSubConnectionUniqueId uniqueID = subconnectionInfo().iSubConnectionUniqueId;

	TESTEL(uniqueID != 0, KErrGeneral);

	// Call GetSubConnectionInfo(TSubConnectionInfo& aSubConnectionIfo)

	err = conn.GetSubConnectionInfo(subconnectionInfo);

	TESTEL(KErrNone == err, err);

	conn.Stop();

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest401

enum TVerdict TE_RConnectionTest402::doTestStepL(void)

{

/**

 *

 * Test 402

 * void AllSubConnectionNotification(TDes8& aNotification, TRequestStatus& aStatus)

 * @return enum TVerdict Indicates status of test run. See INFO_PRINTF1.h for possible values

 */

	TInt err;

	RSocketServ ss;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	RConnection connOne;

	err = OpenConnection(connOne, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(connOne);

	// Start DUMMYNIF

	err = StartConnectionWithOverrides(connOne, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	// Issue request

	TRequestStatus status;

	TSubConnectionNotificationBuf subconnectionNotification;

	connOne.AllSubConnectionNotification(subconnectionNotification, status);

	User::WaitForRequest(status);

	TSubConnectionEvent& event = (TSubConnectionEvent&)(*subconnectionNotification.Ptr());

	TSubConnectionEventType type = event.iEventType;

	// first event from entire connection - ESubConnectionOpened

	TESTEL(ESubConnectionOpened == type, KErrGeneral);

	connOne.AllSubConnectionNotification(subconnectionNotification, status);

	User::WaitForRequest(status);

	// second event from first subconnection - ESubConnectionOpened

	type = event.iEventType;

	TESTEL(ESubConnectionOpened == type, KErrGeneral);

	TUint connectionCount;

	err = connOne.EnumerateConnections(connectionCount);

	TESTEL(KErrNone == err, err);

	// 1 connection

	TESTEL(1 == connectionCount, KErrGeneral);

	// create a socket to allow data to pass

	RSocket sock;

	err = OpenUdpSocketExplicitL(sock, ss, connOne);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	// send some test data to give close event something to return

	err = TestUdpDataPathL(sock, iDummyNifSendAddr);

	TESTEL(KErrNone == err, err);

	// start listen for close event

	TSubConnectionClosedEvent& closeEvent = (TSubConnectionClosedEvent&)(*subconnectionNotification.Ptr());

	connOne.AllSubConnectionNotification(subconnectionNotification, status);

    // Use the EStopAuthoritative stop

	connOne.Stop(RConnection::EStopAuthoritative);

	// small delay

	User::After(E_DELAY);

	// wait for completion

	User::WaitForRequest(status);

	TESTEL(KErrNone == err, err);

	// event from first subconnection - ESubConnectionClosed

	TESTEL(ESubConnectionClosed == closeEvent.iEventType, KErrGeneral);

	TESTEL(KTotalUdpTestPacketSize == closeEvent.iTotalUplinkDataVolume, KErrGeneral);

	TESTEL(KTotalUdpTestPacketSize == closeEvent.iTotalDownlinkDataVolume, KErrGeneral);

	err = connOne.EnumerateConnections(connectionCount);

	TESTEL(KErrNone == err, err);

	TESTEL(0 == connectionCount, KErrGeneral);

	DestroyUdpSocket(sock);

	CleanupStack::Pop();

	CloseConnection(connOne);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest402

enum TVerdict TE_RConnectionTest403::doTestStepL(void)

{

/**

 *

 * Test 403

 * void CancelAllSubConnectionNotification();

 * @return enum TVerdict Indicates status of test run. See INFO_PRINTF1.h for possible values

 */

	TInt err;

	RSocketServ ss;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	RConnection connOne;

	err = OpenConnection(connOne, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(connOne);

	// first we'll check that cancel works on failed connection

	// note that iBadNtRasIap will fail after a few secs

	TRequestStatus status;

	TCommDbConnPref prefs;

	StartConnectionWithOverridesAsynchronous(connOne, prefs, iBadNtRasIap, status);

	// Issue request

	TRequestStatus notifStatus;

	TSubConnectionNotificationBuf subconnectionNotification;

	connOne.AllSubConnectionNotification(subconnectionNotification, notifStatus);

	// now wait for StartConnection to fail

	User::WaitForRequest(status);

	TESTEL(KErrNone != status.Int(), status.Int()); // _should_ fail!!

	// cancel notification - pre-DEF023815 this would hang - so need timeout

	RTimer timer;

	User::LeaveIfError(timer.CreateLocal());

	CleanupClosePushL(timer);

	TRequestStatus timerStatus;

	timer.After(timerStatus, 500000); // allow 500ms to process cancel

	connOne.CancelAllSubConnectionNotification();

	User::WaitForRequest(notifStatus, timerStatus);

	User::WaitForAnyRequest();

	timer.Cancel();

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

	// now start working case by starting dummynif

	err = StartConnectionWithOverrides(connOne, iDummyNifIap);

	TESTEL(KErrNone == err, err);

	// Issue new request

	connOne.AllSubConnectionNotification(subconnectionNotification, status);

	User::WaitForRequest(status);

	TSubConnectionEvent& event = (TSubConnectionEvent&)(*subconnectionNotification.Ptr());

	TSubConnectionEventType type = event.iEventType;

	// event from first connection 

	TESTEL(ESubConnectionOpened == type, KErrGeneral);

	// get next event

	connOne.AllSubConnectionNotification(subconnectionNotification, status);

	User::WaitForRequest(status);

	// event from first subconnection 

	type = event.iEventType;

	TESTEL(ESubConnectionOpened == type, KErrGeneral);

	TUint connectionCount;

	err = connOne.EnumerateConnections(connectionCount);

	TESTEL(KErrNone == err, err);

	// 1 connection

	TESTEL(1 == connectionCount, KErrGeneral);

	connOne.AllSubConnectionNotification(subconnectionNotification, status);

	User::After(E_DELAY);

	// cancel request

	connOne.CancelAllSubConnectionNotification();

	// wait for request completion 

	User::WaitForRequest(status);

	// status code - KErrCancel

	TESTEL(KErrCancel == status.Int(), KErrGeneral);

	CleanupStack::PopAndDestroy(&timer);

	connOne.Stop();

	CloseConnection(connOne);

	CleanupStack::Pop(&connOne);

	CloseSocketServer(ss);

	CleanupStack::Pop(&ss);

	return TestStepResult();

} // TE_RConnectionTest403

enum TVerdict TE_RConnectionTest404::doTestStepL(void)

{

/**

 *

 * Test 404

 * void DataTransferredRequest(TUint& aUplinkVolume, TUint& aDownlinkVolume, TRequestStatus& aStatus); 

 * @return enum TVerdict Indicates status of test run. See INFO_PRINTF1.h for possible values

 */

	TInt err;

	RSocketServ ss;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	RConnection conn;

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	// Start DUMMYNIF

	TRequestStatus status;

	TCommDbConnPref prefs;

	StartConnectionWithOverridesAsynchronous(conn, prefs, iDummyNifIap, status);

	// check return code is correct before startup

	TUint uplinkVolume(0);

	TUint downlinkVolume(0);

	TPckg<TUint> uplinkVolumeDes(uplinkVolume);

	TPckg<TUint> downlinkVolumeDes(downlinkVolume);

	TRequestStatus dtstatus;

	conn.DataTransferredRequest(uplinkVolumeDes, downlinkVolumeDes, dtstatus);

	User::WaitForRequest(dtstatus);

	TESTEL(KErrNotReady == dtstatus.Int(), dtstatus.Int());

	// wait for dummynif to complete startup

	User::WaitForRequest(status);

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

	// start socket