// 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:

// TS_AllInterfaceNotification.cpp

// Contains the implementation of test cases testing the all interface notification 

// functionality of RConnection.

// 

//

/**

 @file

*/

#include "TE_AllInterfaceNotification.h"

#include <ss_std.h>

#define ListOfSuitableIAPs	iHungryNifIap, iDummyNifIap, iDefaultIap, iSecondHungryNifIap, iThirdHungryNifIap, iSecondDummyNifIap, iThirdDummyNifIap, iFourthDummyNifIap, iFifthDummyNifIap

/******************************************************************************

 *

 * Test 300

 *

 *****************************************************************************/

// Constructor

// creates a connection and destroys it again

enum TVerdict TE_RConnectionTest300::doTestStepL(void)

{

	TInt err;

	RConnection activeConn;

	RConnection conn;

	RSocketServ ss;

	TRequestStatus status;

	TInterfaceNotificationBuf info;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = OpenConnection(activeConn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(activeConn);

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	// issue request

	AllInterfaceNotification(conn, status, info);

	// start another different connection to complete request if it hasn't already done so

	err = StartConnectionWithOverrides(activeConn, 1);

	TESTEL(KErrNone == err, err);

	// wait for completion

	User::WaitForRequest(status);

	// check for correct value

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

	CloseConnection(activeConn);

	CleanupStack::Pop();

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest300

/******************************************************************************

 *

 * Test 301

 *

 *****************************************************************************/

// creates a connection and destroys it again

enum TVerdict TE_RConnectionTest301::doTestStepL(void)

{

	TInt err;

	RConnection activeConn;

	RConnection conn;

	RSocketServ ss;

	TRequestStatus status;

	TInterfaceNotificationBuf info;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = OpenConnection(activeConn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(activeConn);

	err = StartConnectionWithOverrides(conn, 1);

	TESTEL(KErrNone == err, err);

	// issue request

	AllInterfaceNotification(conn, status, info);

	// start another different connection to complete request if it hasn't already done so

	err = StartConnectionWithOverrides(activeConn, 6);

	TESTEL(KErrNone == err, err);

	// wait for completion

	User::WaitForRequest(status);

	// check for correct value

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

	CloseConnection(activeConn);

	CleanupStack::Pop();

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest301

/******************************************************************************

 *

 * Test 302

 *

 *****************************************************************************/

// creates a connection and destroys it again

enum TVerdict TE_RConnectionTest302::doTestStepL(void)

{

	TInt err;

	RConnection activeConn;

	RConnection conn;

	RConnection conn2;

	RSocketServ ss;

	TUint numOfConnections;

	TPckgBuf<TConnectionInfo> connInfo;

	TRequestStatus status;

	TInterfaceNotificationBuf info;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = OpenConnection(conn2, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn2);

	err = OpenConnection(activeConn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(activeConn);

	err = StartConnectionWithOverrides(conn, 1);

	TESTEL(KErrNone == err, err);

	// need to call Enumerate() before GetConnectionInfo() to set up array used there

	err = EnumerateConnections(conn, numOfConnections);

	TESTEL(KErrNone == err, err);

	TESTEL(1 == numOfConnections, numOfConnections);

	err = conn.GetConnectionInfo(1, connInfo);

	TESTEL(KErrNone == err, err);

	err = AttachNormal(conn2, connInfo);

	TESTEL(KErrNone == err, err);

	// issue request

	AllInterfaceNotification(conn2, status, info);

	// start another different connection to complete request if it hasn't already done so

	err = StartConnectionWithOverrides(activeConn, 6);

	TESTEL(KErrNone == err, err);

	// wait for completion

	User::WaitForRequest(status);

	// check for correct value

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

	CloseConnection(activeConn);

	CleanupStack::Pop();

	CloseConnection(conn2);

	CleanupStack::Pop();

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest302

/******************************************************************************

 *

 * Test 303

 *

 *****************************************************************************/

// creates a connection and destroys it again

enum TVerdict TE_RConnectionTest303::doTestStepL(void)

{

	TInt err;

	RConnection conn;

	RConnection monConn;

	RSocketServ ss;

	TRequestStatus status;

	TInterfaceNotificationBuf info;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(conn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = OpenConnection(monConn, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(monConn);

	// issue request

	AllInterfaceNotification(monConn, status, info);

	// start another different connection to complete request if it hasn't already done so

	err = StartConnectionWithOverrides(conn, 1);

	TESTEL(KErrNone == err, err);

	// wait for completion - to ensure that monitoring actually occurs

	User::WaitForRequest(status);

	// check for correct value

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

	// issue another request (to be cancelled)

	AllInterfaceNotification(monConn, status, info);

	User::After(iShortTimeout);  // wait for a period of time

	// cancel request

	CancelAllInterfaceNotificationL(monConn);

	// wait for request completion

	User::WaitForRequest(status);

	// check for correct value

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

	CloseConnection(monConn);

	CleanupStack::Pop();

	CloseConnection(conn);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest303

/******************************************************************************

 *

 * Test 304

 *

 *****************************************************************************/

// creates a connection and destroys it again

enum TVerdict TE_RConnectionTest304::doTestStepL(void)

{

	TInt err;

	RSocketServ socketServer;

	RConnection connection;

	RConnection monitor;

	TRequestStatus status;

	TInterfaceNotificationBuf info;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	err = OpenConnection(connection, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(connection);

	err = OpenConnection(monitor, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(monitor);

	// issue request

	AllInterfaceNotification(monitor, status, info);

	// start connection to complete request

	err = StartConnection(connection);

	TESTEL(KErrNone == err, err);

	CheckInterfaceNotificationL(status, info, EInterfaceUp, &connection);

	// issue request

	AllInterfaceNotification(monitor, status, info);

	CloseConnection(connection);

	CleanupStack::Pop();

	CheckInterfaceNotificationL(status, info, EInterfaceDown);

	CloseConnection(monitor);

	CleanupStack::Pop();

	CloseSocketServer(socketServer);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest304

/******************************************************************************

 *

 * Test 305

 *

 *****************************************************************************/

// creates a connection and destroys it again

// Implicitly detect a single connection using SendTo()

enum TVerdict TE_RConnectionTest305::doTestStepL(void)

{

	TInt err;

	RConnection monitor;

	RSocketServ ss;

	RSocket sock;

	TRequestStatus status;

	TInterfaceNotificationBuf info;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(monitor, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(monitor);

	err = OpenUdpSocketL(sock, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	// issue request

	AllInterfaceNotification(monitor, status, info);

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

	TESTEL(KErrNone == err, err);

	// check for interface up...

	CheckInterfaceNotificationL(status, info, EInterfaceUp);

	AllInterfaceNotification(monitor, status, info);

	DestroyUdpSocket(sock);

	CleanupStack::Pop();

	// check for interface down...

	CheckInterfaceNotificationL(status, info, EInterfaceDown);

	CloseConnection(monitor);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest305

/******************************************************************************

 *

 * Test 306

 *

 *****************************************************************************/

// creates a connection and destroys it again

// Implicitly detect a single connection using SendTo()

enum TVerdict TE_RConnectionTest306::doTestStepL(void)

{

	TInt err;

	RSocketServ ss;

	RSocket sock;

	RConnection monitor;

	TRequestStatus status;

	TInterfaceNotificationBuf info;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(monitor, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(monitor);

	err = OpenTcpSocket(sock, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(sock);

	// issue request

	AllInterfaceNotification(monitor, status, info);

	err = ConnectTcpSocket(sock, iEchoServerAddr); // this will use Connect()

	TESTEL(KErrNone == err, err);

	err = TestTcpDataPathL(sock);

	TESTEL(KErrNone == err, err);

	// check for interface up...

	CheckInterfaceNotificationL(status, info, EInterfaceUp);

	// issue request

	AllInterfaceNotification(monitor, status, info);

	err = DestroyTcpSocket(sock);

	TESTEL(KErrNone == err, err);

	CleanupStack::Pop();

	// check for interface down...

	CheckInterfaceNotificationL(status, info, EInterfaceDown);

	CloseConnection(monitor);

	CleanupStack::Pop();

	CloseSocketServer(ss);

	CleanupStack::Pop();

	return TestStepResult();

} // TE_RConnectionTest306

/******************************************************************************

 *

 * Test 307

 *

 *****************************************************************************/

// Implicitly create a single connection using GetByName()

enum TVerdict TE_RConnectionTest307::doTestStepL(void)

{

	TInt err;

	RSocketServ ss;

	RHostResolver hr;

	RConnection monitor;

	TRequestStatus status;

	TInterfaceNotificationBuf info;

	err = OpenSocketServer(ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(ss);

	err = OpenConnection(monitor, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(monitor);

	err = OpenHostResolver(hr, ss);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(hr);

	// issue request

	AllInterfaceNotification(monitor, status, info);

	err = MakeNameRequest(hr, iTestName); // this will use GetByName()

	TESTEL(KErrNone == err, err);

	// check for interface up...

	CheckInterfaceNotificationL(status, info, EInterfaceUp);

	// issue request

	AllInterfaceNotification(monitor, status, info);

	DestroyHostResolver(hr);

	CleanupStack::Pop();

	// check for interface down...

	CheckInterfaceNotificationL(status, info, EInterfaceDown);