// Copyright (c) 2007-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:
// Implementation of those test steps for bearermobility covering the AO based API which is not suitable for
// testing under esock test steps
// 
//

/**
 @file te_BearerMobilityTestSuite.cpp
 @file
*/

#include "te_BearerMobilityTestSuite.h"
#include <ecom/ecom.h>


using namespace ESock;

// CBearerMobilityTestStep_761402
//-------------------------------
static const TInt KPreferredAccessPointId = 4;
static const TInt KLessPreferredAccessPointId = 5;

static const TInt KSnapTwoPreferences = 15;

enum TVerdict CBearerMobilityTestStep_761402::doTestStepL(void)
	{
	// Create and install an active scheduler as we are testing an AO api
	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);

	// Create and connect the socket server
	TInt err;
	err = iSocketServ.Connect();
	TESTEL(err == KErrNone, err);

	// Create and open the connection
	err = iConnection.Open(iSocketServ);
	TESTEL(err == KErrNone, err);

	// Set the availability of each access point of significance
	SetAvailabilityL(
		KPreferredAccessPointId,
		TAvailabilityStatus(TAvailabilityStatus::EMaxAvailabilityScore));
	SetAvailabilityL(
		KLessPreferredAccessPointId,
		TAvailabilityStatus(TAvailabilityStatus::EMaxAvailabilityScore));
	
	// Start the connection
	TCommSnapPref prefs;
	prefs.SetSnap(KSnapTwoPreferences);
	err = iConnection.Start(prefs);
	TESTEL(err == KErrNone, err);

	// Now create the mobility notification AO
	iMobilityExtension = CActiveCommsMobilityApiExt::NewL(iConnection, *this);

	// Make the preferred become unavailable
	SetAvailabilityL(KPreferredAccessPointId, TAvailabilityStatus(TAvailabilityStatus::EMinAvailabilityScore));

	// Bump the state
	BumpTestStepState();

	// Start the scheduler which will ultimately run the rest of the test
	TRAP_IGNORE(CActiveScheduler::Start())
	
	CleanupStack::PopAndDestroy(scheduler);
	
	iConnection.Close();
	iSocketServ.Close();

	return TestStepResult();
	}

// From MMobilityProtocolResp
void CBearerMobilityTestStep_761402::PreferredCarrierAvailable(TAccessPointInfo aOldAP, TAccessPointInfo aNewAP, TBool aIsUpgrade, TBool aIsSeamless)
	{
	switch(GetTestStepState())
		{
		case 1:
			// Check that we got what we expected
			TEST(aOldAP == KPreferredAccessPointId);
			TEST(aNewAP == KLessPreferredAccessPointId);
			TEST(aIsUpgrade == EFalse);
			TEST(aIsSeamless == EFalse);

			// Arrange for migration
			iMobilityExtension->MigrateToPreferredCarrier();

			BumpTestStepState();
			break;

		default:
			INFO_PRINTF1(KErrTestStepAstray);
			SetTestStepResult(EFail);
			break;
		}
	}

void CBearerMobilityTestStep_761402::NewCarrierActive(TAccessPointInfo aNewAP, TBool aIsSeamless)
	{
	switch(GetTestStepState())
		{
		case 2:
			// Check we got what we expected first
			TEST(aNewAP == KLessPreferredAccessPointId);
			TEST(aIsSeamless == EFalse);

			// Accept the new carrier and we are done so stop the scheduler
			iMobilityExtension->NewCarrierAccepted();
			CActiveScheduler::Stop();

			BumpTestStepState();
			break;

		default:
			INFO_PRINTF1(KErrTestStepAstray);
			SetTestStepResult(EFail);
			break;
		}
	}

void CBearerMobilityTestStep_761402::Error(TInt aError)
	{
	// Most likely a cancel but check for any kind of error
	if(aError == KErrCancel)
		{
		INFO_PRINTF1(_L("Mobility extension cancelled"));
		}
	else
		{
		// Some kind of unexpected error during mobility migration
		INFO_PRINTF2(_L("Unexpected error (ordinarily KErrCancel) from mobility extension. error:%d"), aError);
		SetTestStepError(aError);
		}
	}


// CBearerMobilityTestStep_761403
//-------------------------------

enum TVerdict CBearerMobilityTestStep_761403::doTestStepL(void)
	{
	// Fail by default
	SetTestStepResult(EFail);
	
	// Create and connect the socket server
	TInt err;
	RSocketServ sockServ;
	err = sockServ.Connect();
	TESTEL(err == KErrNone, err);

	// Create and open the connection
	RConnection conn;
	err = conn.Open(sockServ);
	TESTEL(err == KErrNone, err);

	// Set the availability of each access point of significance
	SetAvailabilityL(KPreferredAccessPointId, TAvailabilityStatus(TAvailabilityStatus::EMaxAvailabilityScore));
	SetAvailabilityL(KLessPreferredAccessPointId, TAvailabilityStatus(TAvailabilityStatus::EMaxAvailabilityScore));
	
	// Start the connection
	TCommSnapPref prefs;
	prefs.SetSnap(KSnapTwoPreferences);
	err = conn.Start(prefs);
	TESTEL(err == KErrNone, err);

	// Attach a subconn to the default
	RSubConnection subConn;
	err = subConn.Open(sockServ, RSubConnection::EAttachToDefault, conn);
	TESTEL(err == KErrNone, err);

	// Now create the mobility notification and try to open on the subconnection!
	RCommsMobilityApiExt mobExtension;
	err = mobExtension.Open(subConn);
	if(err == KErrNotSupported)
		{
		INFO_PRINTF1(_L("Received KErrNotSupported as expected"));
		SetTestStepResult(EPass);
		}
	else
		{
		INFO_PRINTF2(_L("Negative test: Expect KErrNotSupported. error:%d"), err);
		SetTestStepError(err);
		}
	
	// Close the resources we opened and out of here
	subConn.Close();
	conn.Close();
	sockServ.Close();

	return TestStepResult();
	}

// CBearerMobilityTestStepBase
//----------------------------
const TUid KAvailabilityTestingPubSubUid = {0x10272F42};

void CBearerMobilityTestStepBase::SetAvailabilityL(TInt aAccessPointId, ESock::TAvailabilityStatus aStatus)
	{
	RProperty a;

	// Set the availability of the access point as prescribed
	TInt error = a.Define(KAvailabilityTestingPubSubUid, aAccessPointId, RProperty::EInt);
	if((error != KErrAlreadyExists) && (error != KErrNone))
		{
		INFO_PRINTF1(_L("Could not define property used for availability simulation"));
		User::Leave(KErrGeneral);
		}
	
	// Successfully created the property so attach to it for use
	error = a.Attach(KAvailabilityTestingPubSubUid, aAccessPointId);
	TESTEL(error == KErrNone, error);

	// Now set the availability as prescribed
	a.Set(aStatus.Score());
	}


// Entry point
//------------

LOCAL_C void MainL()
	{
	CActiveScheduler* sched=NULL;
	sched=new(ELeave) CActiveScheduler;
	CActiveScheduler::Install(sched);
	CBearerMobilitySuiteTestServer* server = NULL;

	// Create the CTestServer derived server
	TRAPD(err, server = CBearerMobilitySuiteTestServer::NewL());
	if(!err)
		{
		// Sync with the client and enter the active scheduler
		RProcess::Rendezvous(KErrNone);
		sched->Start();
		}
	delete server;
	delete sched;
	}



GLDEF_C TInt E32Main()
/**
 * @return - Standard Epoc error code on process exit
 * Secure variant only
 * Process entry point. Called by client using RProcess API
 */
	{
	__UHEAP_MARK;
	CTrapCleanup* cleanup = CTrapCleanup::New();
	if(cleanup == NULL)
		{
		return KErrNoMemory;
		}
	TRAPD(err,MainL());
	delete cleanup;
	REComSession::FinalClose();
	__UHEAP_MARKEND;
	return err;
    }




// Test suite server
//------------------

_LIT(KServerName, "te_BearerMobilityTestSuite");

CBearerMobilitySuiteTestServer* CBearerMobilitySuiteTestServer::NewL()
/**
 * @return - Instance of the test server
 * Same code for Secure and non-secure variants
 * Called inside the MainL() function to create and start the
 * CTestServer derived server.
 */
	{
	CBearerMobilitySuiteTestServer* server = new (ELeave) CBearerMobilitySuiteTestServer();
	CleanupStack::PushL(server);
	server->ConstructL(KServerName);
	CleanupStack::Pop();
	return server;
	}
	
CBearerMobilitySuiteTestServer::~CBearerMobilitySuiteTestServer()
	{
	}
	
CTestStep* CBearerMobilitySuiteTestServer::CreateTestStep(const TDesC& aStepName)
/**
 * @return - A CTestStep derived instance
 * Implementation of CTestServer pure virtual
 */
	{
	CTestStep* testStep = NULL;
	if(aStepName.Compare(_L("NET_BMOBILITY_761402")) == 0)
		testStep = new CBearerMobilityTestStep_761402();
	else if(aStepName.Compare(_L("NET_BMOBILITY_761403")) == 0)
		testStep = new CBearerMobilityTestStep_761403();
	
	return testStep;
	}