/*

* Copyright (c) 2008 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:  NAT FW SDP Provider test console release tests impl.

*

*/

#include <e32base.h>

#include <e32cons.h>

#include <centralrepository.h>

#include "nspplugin.h"

#include "nspreleasetest.h"

#include "nsptestconsolesession.h"

#include "nsptestconsolestream.h"

#include "nsptestasyncservice.h"

#include "nsptestconsolemacros.h"

_LIT( KRelease, "Release test" );

_LIT( KNewSession, "NewSession test" );

_LIT( KCreateOffer, "CreateOffer test" );

_LIT( KDecodeAnswer, "DecodeAnswer test" );

_LIT( KResolve, "Resolve test" );

_LIT( KUpdate, "Update test" );

#define PTR_DEL( aPtr ) delete aPtr; aPtr = NULL

// -----------------------------------------------------------------------------

// CNSPReleaseTest::NewL

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest* CNSPReleaseTest::NewL( CNSPPlugin& aApi, CRepository& aRep )

    {

    CNSPReleaseTest* self = CNSPReleaseTest::NewLC( aApi, aRep );

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CNSPReleaseTest::NewLC

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest* CNSPReleaseTest::NewLC( CNSPPlugin& aApi, CRepository& aRep )

    {

    CNSPReleaseTest* self = new ( ELeave ) CNSPReleaseTest;

    CleanupStack::PushL( self );

    self->ConstructL( aApi, aRep );

    return self;

    }

// -----------------------------------------------------------------------------

// CNSPReleaseTest::~CNSPReleaseTest

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::~CNSPReleaseTest()

    {

    iTestArray.ResetAndDestroy();

    }

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPReleaseTest

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPReleaseTest()

	{

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::ConstructL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::ConstructL( CNSPPlugin& aApi, CRepository& aRep )

    {

    CNSPTest* test = NULL;

    test = CNSPTestNewSession::NewLC( aApi, aRep );

    iTestArray.AppendL( test );

    CleanupStack::Pop( test );

    test = CNSPTestCreateOffer::NewLC( aApi, aRep );

    iTestArray.AppendL( test );

    CleanupStack::Pop( test );

    test = CNSPTestDecodeAnswer::NewLC( aApi, aRep );

    iTestArray.AppendL( test );

    CleanupStack::Pop( test );

    /*

    test = CNSPTestResolve::NewLC( aApi, aRep );

    iTestArray.AppendL( test );

    CleanupStack::Pop( test );

	test = CNSPTestUpdate::NewLC( aApi, aRep );

    iTestArray.AppendL( test );

    CleanupStack::Pop( test );

    */

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::SetupL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::SetupL()

	{

    iResult.iDescription.Copy( KRelease() );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::Teardown

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::Teardown()

	{

	TResult::TState result;

	iResult.iState = TResult::EPass;

	for ( TInt i = 0; i < iTestArray.Count(); i++ )

		{

		result = iTestArray[i]->State();

		iResult.iState = ( TResult::EPass != result ?

				 TResult::EFail : iResult.iState );

		}

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::ExecuteL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::ExecuteL( CConsoleBase& aConsole )

	{

	for ( TInt i = 0; i < iTestArray.Count(); i++ )

		{

		iTestArray[i]->StartL( aConsole );

		}

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::Cancel

// -----------------------------------------------------------------------------

//

void CNSPReleaseTest::Cancel()

	{

	for ( TInt i = 0; i < iTestArray.Count(); i++ )

		{

		iTestArray[i]->Cancel();

		}

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::AcceptL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::AcceptL( MNSPTestVisitor& aVisitor )

	{

	aVisitor.VisitL( *this );

	for ( TInt i = 0; i < iTestArray.Count(); i++ )

		{

		iTestArray[i]->AcceptL( aVisitor );

		}

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::NewLC

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestNewSession* CNSPReleaseTest::CNSPTestNewSession::NewLC(

		CNSPPlugin& aApi, CRepository& aRep )

	{

	CNSPReleaseTest::CNSPTestNewSession* self =

			new ( ELeave ) CNSPReleaseTest::CNSPTestNewSession( aApi, aRep );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::ConstructL

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestNewSession::CNSPTestNewSession( CNSPPlugin& aApi, CRepository& aRep )

	: iApi( aApi ),

	  iRep( aRep )

	{

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::ConstructL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestNewSession::ConstructL()

	{

	iAsyncService = CNSPTestAsyncService::NewL( iTimerStatus );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::CNSPTestNewSession

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestNewSession::~CNSPTestNewSession()

	{

	PTR_DEL( iAsyncService );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::SetupL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestNewSession::SetupL()

	{

	iResult.iDescription.Copy( KNewSession() );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::Teardown

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestNewSession::Teardown()

	{

	PTR_DEL( iSession );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::ExecuteL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestNewSession::ExecuteL( CConsoleBase& aConsole )

	{

	PTR_DEL( iSession );

	iSession = CNSPTestConsoleSession::NewL( iApi, iRep, *iAsyncService );

	WAIT( aConsole, "INITIALIZED" );

	iAsyncService->StartScheduler(); // BLOCKING until callback(Initialized)

	COMPLETED_L( aConsole, "INITIALIZED",  iTimerStatus );

	__ASSERT( CNSPTestConsoleSession::EIdle == iSession->State() );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::Cancel

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestNewSession::Cancel()

	{

	iAsyncService->Cancel();

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestCreateOffer::NewLC

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestCreateOffer* CNSPReleaseTest::CNSPTestCreateOffer::NewLC(

		CNSPPlugin& aApi, CRepository& aRep )

	{

	CNSPReleaseTest::CNSPTestCreateOffer* self =

			new ( ELeave ) CNSPReleaseTest::CNSPTestCreateOffer( aApi, aRep );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestCreateOffer::ConstructL

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestCreateOffer::CNSPTestCreateOffer( CNSPPlugin& aApi, CRepository& aRep )

	: CNSPTestNewSession( aApi, aRep )

	{

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestCreateOffer::ConstructL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestCreateOffer::ConstructL()

	{

	CNSPTestNewSession::ConstructL();

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestNewSession::CNSPTestCreateOffer

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestCreateOffer::~CNSPTestCreateOffer()

	{

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestCreateOffer::SetupL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestCreateOffer::SetupL()

	{

	iResult.iDescription.Copy( KCreateOffer() );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestCreateOffer::Teardown

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestCreateOffer::Teardown()

	{

	PTR_DEL( iSession );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestCreateOffer::ExecuteL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestCreateOffer::ExecuteL( CConsoleBase& aConsole )

	{

	CNSPTestNewSession::ExecuteL( aConsole ); // BLOCKING until callback.(Initialized)

	CTestConsoleStream* outStream = CTestConsoleStream::NewL();

	iSession->StoreOutStream( outStream ); // ownership changed.

	TNatReturnStatus status = iSession->CreateOfferL( *outStream );

	if ( KNatAsync == status )

		{

		__ASSERT( CNSPTestConsoleSession::ECreateOffer == iSession->State() );

		WAIT( aConsole, "OFFER READY" );

		iAsyncService->StartScheduler(); // BLOCKING until callback(OfferReady)

		COMPLETED_L( aConsole, "OFFER READY",  iTimerStatus );

		}

	__ASSERT( CNSPTestConsoleSession::EIdle == iSession->State() );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestCreateOffer::NewLC

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestDecodeAnswer* CNSPReleaseTest::CNSPTestDecodeAnswer::NewLC(

		CNSPPlugin& aApi, CRepository& aRep )

	{

	CNSPReleaseTest::CNSPTestDecodeAnswer* self =

			new ( ELeave ) CNSPReleaseTest::CNSPTestDecodeAnswer( aApi, aRep );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestDecodeAnswer::CNSPTestDecodeAnswer

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestDecodeAnswer::CNSPTestDecodeAnswer( CNSPPlugin& aApi, CRepository& aRep )

	: CNSPTestCreateOffer( aApi, aRep )

	{

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestDecodeAnswer::ConstructL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestDecodeAnswer::ConstructL()

	{

	CNSPTestCreateOffer::ConstructL();

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestDecodeAnswer::CNSPTestDecodeAnswer

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestDecodeAnswer::~CNSPTestDecodeAnswer()

	{

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestDecodeAnswer::SetupL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestDecodeAnswer::SetupL()

	{

	iResult.iDescription.Copy( KDecodeAnswer() );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestDecodeAnswer::Teardown

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestDecodeAnswer::Teardown()

	{

	PTR_DEL( iSession );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestDecodeAnswer::ExecuteL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestDecodeAnswer::ExecuteL( CConsoleBase& aConsole )

	{

	CNSPTestCreateOffer::ExecuteL( aConsole ); // BLOCKING until callback.(OfferReady)

	CTestConsoleStream* inStream = CTestConsoleStream::NewL();

	iSession->StoreInStream( inStream ); // ownership changed.

	TNatReturnStatus status = iSession->DecodeAnswerL( *inStream );

	if ( KNatAsync == status )

		{

		__ASSERT( CNSPTestConsoleSession::EDecodeAnswer == iSession->State() );

		WAIT( aConsole, "ANSWER READY" );

		iAsyncService->StartScheduler(); // BLOCKING until callback(AnswerReady)

		COMPLETED_L( aConsole, "ANSWER READY",  iTimerStatus );

		}

	__ASSERT( CNSPTestConsoleSession::EIdle == iSession->State() );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestResolve::NewLC

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestResolve* CNSPReleaseTest::CNSPTestResolve::NewLC(

		CNSPPlugin& aApi, CRepository& aRep )

	{

	CNSPReleaseTest::CNSPTestResolve* self =

	new ( ELeave ) CNSPReleaseTest::CNSPTestResolve( aApi, aRep );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestResolve::CNSPTestResolve

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestResolve::CNSPTestResolve( CNSPPlugin& aApi, CRepository& aRep )

	: CNSPTestNewSession( aApi, aRep )

	{

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestResolve::ConstructL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestResolve::ConstructL()

	{

	CNSPTestNewSession::ConstructL();

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestResolve::~CNSPTestResolve

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestResolve::~CNSPTestResolve()

	{

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestResolve::SetupL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestResolve::SetupL()

	{

	iResult.iDescription.Copy( KResolve() );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestResolve::Teardown

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestResolve::Teardown()

	{

	PTR_DEL( iSession );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestResolve::ExecuteL

// -----------------------------------------------------------------------------

// 

void CNSPReleaseTest::CNSPTestResolve::ExecuteL( CConsoleBase& aConsole )

	{

	CNSPTestNewSession::ExecuteL( aConsole ); // BLOCKING until callback.(Initialized)

	CTestConsoleStream* inStream = CTestConsoleStream::NewL();

	iSession->StoreInStream( inStream ); // ownership changed.

	CTestConsoleStream* outStream = CTestConsoleStream::NewL();

	iSession->StoreInStream( outStream ); // ownership changed.

	TNatReturnStatus status = iSession->ResolveL( *inStream, *outStream );

	if ( KNatAsync == status )

		{

		__ASSERT( CNSPTestConsoleSession::ECreateAnswer == iSession->State() );

		WAIT( aConsole, "ANSWER READY" );

		iAsyncService->StartScheduler(); // BLOCKING until callback(AnswerReady)

		COMPLETED_L( aConsole, "ANSWER READY",  iTimerStatus );

		__ASSERT( CNSPTestConsoleSession::EDecodeOffer == iSession->State() );

		WAIT( aConsole, "OFFER READY" );

		iAsyncService->StartScheduler(); // BLOCKING until callback(OfferReady)

		COMPLETED_L( aConsole, "OFFER READY",  iTimerStatus );

		}

	__ASSERT( CNSPTestConsoleSession::EIdle == iSession->State() );

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestUpdate::NewLC

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestUpdate* CNSPReleaseTest::CNSPTestUpdate::NewLC(

		CNSPPlugin& aApi, CRepository& aRep )

	{

	CNSPReleaseTest::CNSPTestUpdate* self =

	new ( ELeave ) CNSPReleaseTest::CNSPTestUpdate( aApi, aRep );

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

// -----------------------------------------------------------------------------

// CNSPReleaseTest::CNSPTestUpdate::CNSPTestUpdate

// -----------------------------------------------------------------------------

// 

CNSPReleaseTest::CNSPTestUpdate::CNSPTestUpdate( CNSPPlugin& aApi, CRepository& aRep )

	: CNSPTestNewSession( aApi, aRep )

	{

	}