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

//

#include "BCTestSection2.h"

#include <comms-infras/nifif.h>

#include <in_sock.h>

#include <CommDbConnPref.h>

#include <es_enum.h>

CTestStep2_1::CTestStep2_1() 

//

// C'tor

//

	{

	_LIT(KTestStepName, "Test2_1");

	iTestStepName = KTestStepName();

	}

enum TVerdict CTestStep2_1::doTestStepL()

//

// Test that RNif::Stop() does not interfere with other connections

//

	{

	TInt err(KErrNone);

	RSocketServ ss;

	err = ss.Connect();

	TESTEL(err==KErrNone, err);

	CleanupClosePushL(ss);

	Log(_L("Starting implicit connection using RSocket::SendTo()"));

	RSocket sock;

	err = sock.Open(ss, KAfInet, KSockDatagram, KProtocolInetUdp);

	TESTEL(err==KErrNone, err);

	CleanupClosePushL(sock);

	TInetAddr local(KInetAddrAny, KInetPortAny);

	err = sock.Bind(local);

	TESTEL(err==KErrNone, err);

	TInetAddr dest(INET_ADDR(1, 2, 3, 4), 9);  // IP address does not matter here - we're not expecting a response

	TBuf8<0x100> buf;

	buf.Fill(TChar('A'), buf.MaxLength ());

	TRequestStatus status;

	sock.SendTo(buf, dest, 0, status);

	User::WaitForRequest(status);

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

	RConnection conn;

	err = conn.Open(ss);

	TESTEL(err==KErrNone, err);

	CleanupClosePushL(conn);

	TUint count(0);

	err = conn.EnumerateConnections(count);

	TESTE(err==KErrNone, err);

	TEST(count==1);

	Log(_L("%d connections active"), count);

	TConnectionInfoBuf info;

	err = conn.GetConnectionInfo(count, info);

	TESTE(err==KErrNone, err);

	TInt implicitIAP = info().iIapId;

	Log(_L("Implicit connection has IAP ID %d"), implicitIAP);

	Log(_L("Starting explicit connection using RConnection::Start()"));

	TCommDbConnPref pref;

	pref.SetIapId(2);

	err = conn.Start(pref);

	TESTEL(err==KErrNone, err);

	err = conn.EnumerateConnections(count);

	TESTE(err==KErrNone, err);

	TEST(count==2);

	Log(_L("%d connections active"), count);

	err = conn.GetConnectionInfo(count, info);

	TESTE(err==KErrNone, err);

	TInt explicitIAP = info().iIapId;

	Log(_L("Explicit connection has IAP ID %d"), explicitIAP);

	Log(_L("Calling RNif::Stop()"));

	RNif            nif;

	TNifProgressBuf prog;

	err = nif.Open();

	TESTEL(err==KErrNone, err);

	nif.ProgressNotification(prog, status);

	TNifAgentInfo agentInfo;

	err = nif.AgentInfo(agentInfo);

	TESTEL(err==KErrNone, err);

	TBool isNetworkActive;

	err = nif.NetworkActive(isNetworkActive);

	Log(_L("Network active is %d"), isNetworkActive);

	Log(_L("Disabling timers for NIF"));

        err = nif.DisableTimers(ETrue);

	TESTEL(err==KErrNone, err);

	nif.Stop();

    Log(_L("Waiting for implicit connection to disconnect"));

    for(;;)

    {

        User::WaitForRequest(status);//wait on progress notification

        //-- we must subscribe to notification ASAP in order not to miss 

        //-- status change

        nif.ProgressNotification(prog, status);

        //-- status may have changed even during ProgressNotification call

        nif.Progress(prog());

        TInt nConnStage = prog().iStage;

        TInt nConnErr   = prog().iError;

        if(nConnStage == KAgentUninitialised)

                break;

        Log(_L("Stage %d, error %d"), nConnStage, nConnErr);            

    }

	nif.Close();

	err = conn.EnumerateConnections(count);

	TESTE(err==KErrNone, err);

	TEST(count==1);

	Log(_L("%d connections active"), count);

	err = conn.GetConnectionInfo(count, info);

	TESTE(err==KErrNone, err);

	TInt remainingIAP = info().iIapId;

	Log(_L("Remaining connection has IAP ID %d"), remainingIAP);

	TEST(explicitIAP==remainingIAP);

	Log(_L("Stopping connection using RConnection::Stop()"));

	conn.Stop();

	sock.Close();

	CleanupStack::Pop();  // sock

	conn.Close();

	CleanupStack::Pop();  // conn

	ss.Close();

	CleanupStack::Pop();  // ss

	return iTestStepResult;

	}

CTestStep2_2::CTestStep2_2() 

//

// C'tor

//

	{

	_LIT(KTestStepName, "Test2_2");

	iTestStepName = KTestStepName();

	}

enum TVerdict CTestStep2_2::doTestStepL()

//

// Test the RGenericAgent connection idle timers

//

	{

	TInt err(KErrNone);

	RTimer timer;

	err = timer.CreateLocal();

	TESTEL(err==KErrNone, err);

	CleanupClosePushL(timer);

	RSocketServ ss;

	err = ss.Connect();

	TESTEL(err==KErrNone, err);

	CleanupClosePushL(ss);

	RConnection conn;

	err = conn.Open(ss);

	TESTEL(err==KErrNone, err);

	RGenericAgent agent;

	err = agent.Open();

	TESTEL(err==KErrNone, err);

	CleanupClosePushL(agent);

	Log(_L("Starting implicit connection using RSocket::SendTo()"));

	RSocket sock;

	err = sock.Open(ss, KAfInet, KSockDatagram, KProtocolInetUdp);

	TESTEL(err==KErrNone, err);

	CleanupClosePushL(sock);

	TInetAddr local(KInetAddrAny, KInetPortAny);

	err = sock.Bind(local);

	TESTEL(err==KErrNone, err);

	TInetAddr dest(INET_ADDR(1, 2, 3, 4), 9);  // IP address does not matter here - we're not expecting a response

	TBuf8<0x100> buf;

	buf.Fill(TChar('A'), buf.MaxLength ());

	TRequestStatus status;

	sock.SendTo(buf, dest, 0, status);

	User::WaitForRequest(status);

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

	TUint32 socketActivityTO;

	err = agent.GetActiveIntSetting(TPtrC(MODEM_BEARER), TPtrC(LAST_SOCKET_ACTIVITY_TIMEOUT), socketActivityTO);

	TESTEL(err==KErrNone, err);

	agent.Close();

	CleanupStack::Pop(2);    // socket and agent

	CleanupClosePushL(sock); // put socket back - it is still in use

	// set timer for the last socket activity timeout (with a 5% margin)

	const TUint32 KMarginFactor = 20; //  5% = 1/20

	TUint32 timeout = (socketActivityTO + (socketActivityTO/KMarginFactor))*1000000;

	TRequestStatus timerStatus;

	timer.After(timerStatus, timeout);

	User::WaitForRequest(timerStatus);

	TESTE(timerStatus.Int()==KErrNone, timerStatus.Int());

	TUint count(0);

	err = conn.EnumerateConnections(count);

	TESTE(err==KErrNone, err);

	TEST(count==0);

	Log(_L("%d connections active"), count);

	sock.Close();

	CleanupStack::Pop();  // sock

	ss.Close();

	CleanupStack::Pop();  // ss

	timer.Close();

	CleanupStack::Pop();  // timer

	return iTestStepResult;

	}

CTestStep2_3::CTestStep2_3() 

//

// C'tor

//

	{

	_LIT(KTestStepName, "Test2_3");

	iTestStepName = KTestStepName();

	}

enum TVerdict CTestStep2_3::doTestStepL()

//

// Test the RNifMonitor and KErrNone tests

//

    {

    TSoIfConnectionInfo connectionInfo, connectionInfoCopy;

    connectionInfo.iNetworkId = 170;

    connectionInfo.iIAPId = 55;

    connectionInfoCopy = connectionInfo;

	// Verify the == operator is implemented correctly

    TESTE(connectionInfoCopy == connectionInfo, KErrGeneral);

    TInt err(KErrNone);

    RNifMonitor mon;

    err = mon.Open(_L("genconn.agt"));

    TESTE(err == KErrNone, err);

    mon.Close();

    return EPass;

    }

CTestStep2_4::CTestStep2_4() 

//

// C'tor

//

	{

	_LIT(KTestStepName, "Test2_4");

	iTestStepName = KTestStepName();

	}

enum TVerdict CTestStep2_4::doTestStepL()

//

// Test unsupported nif methods

//

    {

    // MNifIfNotify* notify = (MNifIfNotify*) 0x12345678;  // value doesn't matter here as the we check that this method leaves

    //CNifIfBase* nif;

    // Implement this when we support panics

    TRAPD(err, User::Leave(KErrNotSupported)); //nif = Nif::CreateInterfaceL(_L("PPP"), notify));

    if(err != KErrNotSupported)

        {

        return EFail;

        }

    return EPass;

    }