// Copyright (c) 2003-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 use real ethernet

// as the default interface. These tests test that connections requiring

// configuration by configuration daemons such as DHCP start successfully

// and that they can be queried using the Ioctl() function.

// 

//

/**

 @file

*/

#include "TE_RConnectionConfigDaemonTestSteps.h"

#include <nifman.h>

#include <comms-infras/es_config.h>

TE_RConnectionTest600::~TE_RConnectionTest600() {}

enum TVerdict TE_RConnectionTest600::doTestStepL(void)

/**

  * The test starts an ethernet connection requiring DHCP address

  * configuration.  If the connection starts then DHCP and everything

  * else went fine!

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	StopConnection(conn);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}

TE_RConnectionTest601::~TE_RConnectionTest601() {}

enum TVerdict TE_RConnectionTest601::doTestStepL(void)

/**

  * The test starts an ethernet connection requiring DHCP address

  * configuration then queries it for the configured address.

  * To check the validity of the address retrieved a socket is

  * bound to it.  If this fails the address returned is not correct

  * with respect to the one configured for the connection by DHCP.

  * The bind is a useful way of checking the address, as it will

  * only succeed if the TCP/IP6 stack has a route for the address.

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	TRequestStatus stat;	

	TConnectionAddrBuf address;

	address().iAddressFamily = KAfInet;

	conn.Ioctl(KCOLConfiguration, KConnGetCurrentAddr, stat, &address);

	User::WaitForRequest(stat);

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

	RSocket socket;

	err = socket.Open(socketServer, KAfInet, KSockDatagram, KProtocolInetUdp, conn);

	TESTEL(err == KErrNone, err);

	CleanupClosePushL(socket);

	TInetAddr* properAddr = (TInetAddr*)&(address().iAddr);	

	TInetAddr addr;

	addr.SetAddress(properAddr->Address());

	err = socket.Bind(addr);

	TESTEL(err == KErrNone, err);

	CleanupStack::PopAndDestroy(&socket);

	StopConnection(conn);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}

TE_RConnectionTest602::~TE_RConnectionTest602() {}

enum TVerdict TE_RConnectionTest602::doTestStepL(void)

/**

  * The test starts an ethernet connection requiring DHCP address configuration

  * and stops it again.  It then attempts to find out the address that was used 

  * for the connection when it was up.  This will fail, with KErrNotReady, as 

  * the DHCP configuration daemon can no longer be queried for the address of a 

  * connection, as the connection has gone down, therefore the config daemon's 

  * record of the connection has been deleted.

  *

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	StopConnection(conn);

	TRequestStatus stat;		

	TConnectionAddrBuf address;

	address().iAddressFamily = KAfInet;

	conn.Ioctl(KCOLConfiguration, KConnGetCurrentAddr, stat, &address);

	User::WaitForRequest(stat);

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

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}

TE_RConnectionTest603::~TE_RConnectionTest603() {}

enum TVerdict TE_RConnectionTest603::doTestStepL(void)

/**

  * The test attempts to query RConnection for the address of the connection

  * but the connection has not been started.

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	TRequestStatus stat;

	TConnectionAddrBuf address;

	address().iAddressFamily = KAfInet;

	conn.Ioctl(KCOLConfiguration, KConnGetCurrentAddr, stat, &address);

	User::WaitForRequest(stat);

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

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}

TE_RConnectionTest604::~TE_RConnectionTest604() {}

enum TVerdict TE_RConnectionTest604::doTestStepL(void)

/**

  * The test starts an ethernet connection that requires DHCP address configuration

  * and queries for the configured address and stopping the connection before waiting

  * for the query to complete.

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	TRequestStatus stat;

	conn.Ioctl(KCOLConfiguration, KConnAddrRenew, stat);

	StopConnection(conn);

	User::WaitForRequest(stat);

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

	StopConnection(conn);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}

TE_RConnectionTest605::~TE_RConnectionTest605() {}

enum TVerdict TE_RConnectionTest605::doTestStepL(void)

/**

  * The test starts an ethernet connection requiring DHCP address configuration

  * and querying to renew the lease before calling the query. The 

  * request will complete with KErrCancel and will not be fulfilled.

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	TRequestStatus stat;

	conn.Ioctl(KCOLConfiguration, KConnAddrRenew, stat);

	conn.CancelIoctl();

	User::WaitForRequest(stat);

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

	StopConnection(conn);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}

TE_RConnectionTest606::~TE_RConnectionTest606() {}

enum TVerdict TE_RConnectionTest606::doTestStepL(void)

/**

  * The test starts an ethernet connection requiring DHCP address configuration

  * and calling cancelIoctl without ever having an Ioctl request outstanding.

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	conn.CancelIoctl();	// does nothing in this state

	StopConnection(conn);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}

TE_RConnectionTest607::~TE_RConnectionTest607() {}

enum TVerdict TE_RConnectionTest607::doTestStepL(void)

/**

  * The test starts an ethernet connection requiring DHCP address configuration

  * but calls canclIoctl() first without having an outstanding ioctl request.

  * It then starts a connection does a proper Ioctl query to check the cancel

  * isn't somehow wrongly cached and then stops the connection just to check 

  * that no functionality is interferred with by the cancel.

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	conn.CancelIoctl();	// does nothing in this state

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	// now do a query to check cancel isn;t cached somehow...

	TRequestStatus stat;	

	TConnectionAddrBuf address;

	address().iAddressFamily = KAfInet;

	conn.Ioctl(KCOLConfiguration, KConnGetCurrentAddr, stat, &address);

	User::WaitForRequest(stat);

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

	RSocket socket;

	err = socket.Open(socketServer, KAfInet, KSockDatagram, KProtocolInetUdp, conn);

	TESTEL(err == KErrNone, err);

	CleanupClosePushL(socket);

	TInetAddr* properAddr = (TInetAddr*)&(address().iAddr);	

	TInetAddr addr;

	addr.SetAddress(properAddr->Address());

	err = socket.Bind(addr);

	TESTEL(err == KErrNone, err);

	CleanupStack::PopAndDestroy(&socket);

	StopConnection(conn);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}

TE_RConnectionTest608::~TE_RConnectionTest608() {}

enum TVerdict TE_RConnectionTest608::doTestStepL(void)

/**

  * The test starts an ethernet connection requiring DHCP address configuration

  * then calls canclIoctl() without having an outstanding ioctl request.

  * It then queries for the configured address to ensure that no functionality has been

  * interferred with by the cancel.

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	err = StartConnection(conn);

	TESTEL(KErrNone == err, err);

	conn.CancelIoctl();	// does nothing in this state

	TRequestStatus stat;

	TConnectionAddrBuf address;

	address().iAddressFamily = KAfInet;

	conn.Ioctl(KCOLConfiguration, KConnGetCurrentAddr, stat, &address);

	User::WaitForRequest(stat);

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

	RSocket socket;

	err = socket.Open(socketServer, KAfInet, KSockDatagram, KProtocolInetUdp, conn);

	TESTEL(err == KErrNone, err);

	CleanupClosePushL(socket);

	TInetAddr* properAddr = (TInetAddr*)&(address().iAddr);	

	TInetAddr addr;

	addr.SetAddress(properAddr->Address());

	err = socket.Bind(addr);

	TESTEL(err == KErrNone, err);

	CleanupStack::PopAndDestroy(&socket);

	StopConnection(conn);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}

TE_RConnectionTest609::~TE_RConnectionTest609() {}

enum TVerdict TE_RConnectionTest609::doTestStepL(void)

/**

  * The test starts an ethernet connection requiring DHCP address configuration

  * asynchronously and queries for the configured address before the start completes.

  */

	{

	TInt err;

	RSocketServ socketServer;

	err = OpenSocketServer(socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(socketServer);

	RConnection conn;

	err = OpenConnection(conn, socketServer);

	TESTEL(KErrNone == err, err);

	CleanupClosePushL(conn);

	TRequestStatus stat1;

	StartConnectionAsynchronous(conn, stat1);

	TRequestStatus stat2;

	TConnectionAddrBuf address;

	address().iAddressFamily = KAfInet;

	conn.Ioctl(KCOLConfiguration, KConnGetCurrentAddr, stat2, &address);

	User::WaitForRequest(stat2);

	User::WaitForRequest(stat1);

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

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

	StopConnection(conn);

	CleanupStack::PopAndDestroy(&conn);

	CleanupStack::PopAndDestroy(&socketServer);	// just sanity check our pops

	return TestStepResult();

	}