/*

* Copyright (c) 2004 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:  

*

*/

//  CLASS HEADER

#include "ut_cfcsender.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "fcsender.h"

const TInt KTimerDelay = 500;

const TUint KIAPID = 6;

const TInt KLength = 50;

const TInt KPort1 = 2000;

const TInt KPort2 = 3000;

const TInt KSendBufferLen = 10;

_LIT(KAddr, "127.0.0.1");

_LIT8(KHello, "hello...testing");

#define FC_EUNIT_ASSERT_SPECIFIC_LEAVE( func, val ) \

{\

TRAPD( fcUnitTestRetVal, func );\

if ( val != KErrNoMemory && fcUnitTestRetVal == KErrNoMemory ){\

	User::Leave( KErrNoMemory );\

	}\

else{\

	EUNIT_ASSERT_EQUALS( fcUnitTestRetVal, val );\

	}\

}

#define FC_EUNIT_ASSERT_NO_LEAVE( func ) FC_EUNIT_ASSERT_SPECIFIC_LEAVE( func, KErrNone )

#define FC_EUNIT_ASSERT_SPECIFIC_LEAVE( func, val ) \

{\

TRAPD( fcUnitTestRetVal, func );\

if ( val != KErrNoMemory && fcUnitTestRetVal == KErrNoMemory ){\

	User::Leave( KErrNoMemory );\

	}\

else{\

	EUNIT_ASSERT_EQUALS( fcUnitTestRetVal, val );\

	}\

}

// CONSTRUCTION

UT_CFCSender* UT_CFCSender::NewL()

    {

    UT_CFCSender* self = UT_CFCSender::NewLC(); 

    CleanupStack::Pop(self);

    return self;

    }

UT_CFCSender* UT_CFCSender::NewLC()

    {

    UT_CFCSender* self = new( ELeave ) UT_CFCSender();

    CleanupStack::PushL( self );

	self->ConstructL(); 

    return self;

    }

// Destructor (virtual by CBase)

UT_CFCSender::~UT_CFCSender()

    {

    }

// Default constructor

UT_CFCSender::UT_CFCSender()

    {

    }

// Second phase construct

void UT_CFCSender::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CFCSender::SetupL(  )

    {

    iSimplifiedConnect = EFalse;

    iConnection = CFCConnectionContainer::NewL(*this);

	User::LeaveIfError( iSocketServ.Connect( KESockDefaultMessageSlots) );

	iEventCount = 0;    

	iTimer = CPeriodic::NewL( EPriorityNormal );

    } 

void UT_CFCSender::Teardown(  )

    {

	delete iTimer;

	iTimer = NULL;

    if (iSender)

		{

		iSender->Cancel();

		}

	if(iConnection)

		{

		iConnection->CloseConnection();

		}

	iSocket.Close();

    delete iSender;

    iSender = NULL;

    delete iConnection;

    iConnection = NULL;

    iSocketServ.Close();

    delete iData;

    iData= NULL;

    }

void UT_CFCSender::UT_CFCSender_NewLL(  )

    {

    iConnection->OpenConnection(KIAPID, iSocketServ  );

    iSender = CFCSender::NewL(iSocket, *this);

    iConnection->Cancel(); 

    iConnection->RunL(); 

    EUNIT_ASSERT( iErr==0);

    }

void UT_CFCSender::UT_CFCSender_SendLL(  )

    {

  	iConnection->OpenConnection(KIAPID, iSocketServ  );

	iSender = CFCSender::NewL(iSocket, *this);

	iConnection->Cancel();

	iConnection->iStatus = KErrNone;

    iConnection->RunL();

    EUNIT_ASSERT( iErr==0);

	iSender->Cancel();

    iSender->iStatus = KErrNone;

    iSender->RunL();

    TInetAddr addr;

    addr.Input(KAddr);

    addr.SetPort(KPort2);

    HBufC8* data = HBufC8::NewLC(KLength);

	data->Des().Copy(KHello);

	FC_EUNIT_ASSERT_NO_LEAVE(iSender ->SendL(data, addr));

	CleanupStack::Pop( data );

    iSender->Cancel();

    }

void UT_CFCSender::UT_CFCSender_SendL2L(  )

    {

    // Test when is active.

    iConnection->OpenConnection(KIAPID, iSocketServ  );

    iSender = CFCSender::NewL(iSocket, *this);

	iConnection->Cancel(); 

	iConnection->iStatus = KErrNone;

    iConnection->RunL(); 

	iSender->Cancel();

    iSender->iStatus = KErrNone;

    iSender->RunL();

	EUNIT_ASSERT( iErr==0 );

	TInetAddr addr;

    addr.Input(KAddr);

    addr.SetPort(KPort2);

    HBufC8* data = HBufC8::NewLC(KLength);

	    data->Des().Copy(KHello);

    FC_EUNIT_ASSERT_NO_LEAVE(iSender ->SendL(data, addr));    

    CleanupStack::Pop( data );

    iSender->Cancel();

    iSender->iStatus = KErrNone;

    iSender->RunL();

    }

void UT_CFCSender::UT_CFCSender_SendL3L(  )

    {

    // Test with active and full buffer

    iConnection->OpenConnection(KIAPID, iSocketServ  );

    iSender = CFCSender::NewL(iSocket, *this);

	iConnection->Cancel(); 

 	iConnection->iStatus = KErrNone;

    iConnection->RunL(); 

    iSender->Cancel();

    iSender->iStatus = KErrNone;

    iSender->RunL();

	EUNIT_ASSERT( iErr==0 );

    TInetAddr addr;

    addr.Input(KAddr);

    addr.SetPort(KPort2);

    HBufC8* data = HBufC8::NewLC(KLength);

	    data->Des().Copy(KHello);

    // fill the send buffer

    while( iSender->iSendBuffer.Count() < KSendBufferLen )

        {

        HBufC8* data2 = HBufC8::NewLC(KLength);

	    data2->Des().Copy(KHello);

        iSender->iSendBuffer.AppendL( data2 );      

        CleanupStack::Pop( data2 );

        }

    iSender ->SendL(data, addr); 

    CleanupStack::Pop( data );

    HBufC8* data3 = HBufC8::NewLC(KLength);

	    data3->Des().Copy(KHello);

	EUNIT_ASSERT_LEAVE(iSender ->SendL( data3, addr ));    	    

	CleanupStack::PopAndDestroy( data3 );

    iSender->iSendBuffer.ResetAndDestroy();      

   	iSender->Cancel();

    iSender->iStatus = KErrNone;

    iSender->RunL();

    }

void UT_CFCSender::UT_CFCSender_SendL4L(  )

    {

    // Test sending when connection is not started yet, send is queued

    iSimplifiedConnect = ETrue;

    iConnection->OpenConnection(KIAPID, iSocketServ  );

    iSender = CFCSender::NewL(iSocket, *this); 

    TInetAddr addr;

    addr.Input(KAddr);

    addr.SetPort(KPort2);

    HBufC8* data = HBufC8::NewLC(KLength);

    data->Des().Copy(KHello);

    EUNIT_ASSERT_EQUALS( iSender->iSendBuffer.Count(), 0 );

    FC_EUNIT_ASSERT_NO_LEAVE(iSender ->SendL(data, addr));

    CleanupStack::Pop( data );

    EUNIT_ASSERT_EQUALS( iSender->iSendBuffer.Count(), 1 );

    EUNIT_ASSERT( !iSender->IsActive() );

    // Connection gets started and sending of queued buffer is activated

    iConnection->Cancel(); 

    iConnection->iStatus = KErrNone;

    iConnection->RunL();

    EUNIT_ASSERT_EQUALS( iSender->iSendBuffer.Count(), 0 );

    EUNIT_ASSERT( iSender->IsActive() );

    }

void UT_CFCSender::UT_CFCSender_RunErrorL(  )

    {

    iSender  = CFCSender::NewL(iSocket, *this);

	EUNIT_ASSERT( iSender->RunError(KErrNoMemory) == KErrNoMemory);

	EUNIT_ASSERT( iSender->RunError(KErrBadName) == KErrNone);

	}

void UT_CFCSender::UT_CFCSender_DoCancelL(  )

    {

    iConnection->OpenConnection(KIAPID, iSocketServ  );

    iSender = CFCSender::NewL(iSocket, *this);

    iConnection->Cancel(); 

    iConnection->RunL(); 

	iSender->DoCancel();

	EUNIT_ASSERT( iErr==0 );

	}

void UT_CFCSender::UT_CFCSender_TestRunLL(  )

	{

	// KErrNoMemory

	iSender = CFCSender::NewL(iSocket, *this);

	iConnection->Cancel(); 

	iConnection->iStatus = KErrNone;

    iConnection->RunL(); 

	iSender->Cancel();

    iSender->iStatus = KErrNoMemory;

    EUNIT_ASSERT_SPECIFIC_LEAVE( iSender->RunL(), KErrNoMemory );

 	iSender->Cancel();

	}

void UT_CFCSender::UT_CFCSender_TestRunL2L(  )

	{

	// data in buffer

	iConnection->OpenConnection( KIAPID, iSocketServ  );

	iSender = CFCSender::NewL(iSocket, *this);

	iConnection->Cancel(); 

	iConnection->iStatus = KErrNone;

    iConnection->RunL(); 

    iSender->Cancel();

    iSender->iStatus = KErrNone;

    iSender->RunL();

	HBufC8* data = HBufC8::NewLC(KLength);

	data->Des().Copy(KHello);

    iSender->iSendBuffer.AppendL( data );

	FC_EUNIT_ASSERT_NO_LEAVE( iSender->RunL() );

    CleanupStack::Pop( data );

 	iSender->Cancel();

	}

void UT_CFCSender::ReceivedData(HBufC8* aData)

	{

	iData=aData;

	}

void UT_CFCSender::ErrorNotify(TInt aErrCode)

	{

	iErr=aErrCode;

	}

void UT_CFCSender::ConnectionStarted( TInt aError )

	{

	TRAPD(leaveErr ,ConnectionStartedL(aError) );

	if(leaveErr!=KErrNone)

		{

		ErrorNotify( leaveErr);	

		}

	iErr=aError;

	}	

void UT_CFCSender::ConnectionStartedL( TInt aError )

	{

	if(aError==KErrNone)

		{	

		iSender->ConnectedL();

		User::LeaveIfError(iSocket.Open(iSocketServ, KAfInet, KSockDatagram,

								KProtocolInetUdp, iConnection->Connection()) );

		TInetAddr addr;

		addr.SetAddress(KInetAddrAny);

		addr.SetPort(KPort1);

		TInt err = iSocket.Bind(addr);

		if (err == KErrInUse)

			{

			iErr = KErrInUse;

			}

		else

			{

			iErr = err;

			}

		}

	EUNIT_ASSERT(iErr==0);

	if ( !iSimplifiedConnect )

	    {

        TInetAddr addr2;

        addr2.Input(KAddr);

        addr2.SetPort(KPort2);

        HBufC8* data = HBufC8::NewLC(KLength);

        data->Des().Copy(KHello);

        iSender ->SendL(data, addr2);

        CleanupStack::Pop(data);

        iConnection->Cancel();

        iConnection->RunL();

        iConnection->iStatus = KErrNone;

        EUNIT_ASSERT(iErr==0);

	    }

	}

TInt UT_CFCSender::StopScheduler( TAny* aThis )

	{

	UT_CFCSender* self = reinterpret_cast< UT_CFCSender* >( aThis );

	// set test to pass and stop scheduler

	self->iCallBackCalled = ETrue;

	return 0;

	}

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE( 

    UT_CFCSender,

    "UT_CFCSender",

    "UNIT" )

EUNIT_TEST(

    "NewL - test ",

    "CFCSender",

    "NewL",

    "FUNCTIONALITY",

    SetupL, UT_CFCSender_NewLL, Teardown)

EUNIT_TEST(

    "SendL - test ",

    "CFCSender",

    "SendL",

    "FUNCTIONALITY",

    SetupL, UT_CFCSender_SendLL, Teardown)

EUNIT_TEST(

    "SendL - test 2",

    "CFCSender",

    "SendL",

    "FUNCTIONALITY",

    SetupL, UT_CFCSender_SendL2L, Teardown)

EUNIT_TEST(

    "SendL - test 3",

    "CFCSender",

    "SendL",

    "FUNCTIONALITY",

    SetupL, UT_CFCSender_SendL3L, Teardown)

EUNIT_TEST(

    "SendL - test 4",

    "CFCSender",

    "SendL",

    "FUNCTIONALITY",

    SetupL, UT_CFCSender_SendL4L, Teardown)

EUNIT_TEST(

    "RunError - test ",

    "CFCSender",

    "RunError",

    "FUNCTIONALITY",

    SetupL, UT_CFCSender_RunErrorL, Teardown)

EUNIT_TEST(

    "DoCancel - test ",

    "CFCSender",

    "DoCancel",

    "FUNCTIONALITY",

    SetupL, UT_CFCSender_DoCancelL, Teardown)

EUNIT_TEST(

    "RunL - test ",

    "CFCSender",

    "RunL",

    "FUNCTIONALITY",

    SetupL, UT_CFCSender_TestRunLL, Teardown)

EUNIT_TEST(

    "RunL - test 2",

    "CFCSender",

    "RunL",

    "FUNCTIONALITY",

    SetupL, UT_CFCSender_TestRunL2L, Teardown)

EUNIT_END_TEST_TABLE

//  END OF FILE