/*

* 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_CMccDlDataPath.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

//  INTERNAL INCLUDES

#include "mccdldatapath.h"

#include "MccRtpDatasource.h"

#include "MccRtpDataSink.h"

#include "mccresourcepool_stub.h"

#include "mccuids.hrh"

#include "mccinternaldef.h"

#include "AmrPayloadFormatRead.h"

#include "mccunittestmacros.h"

const TUid KRtpDataSource            =  { KImplUidRtpDataSource   }; 

const TUid KRtpDataSink              =  { KImplUidRtpDataSink     };

// CONSTRUCTION

UT_CMccDlDataPath* UT_CMccDlDataPath::NewL()

    {

    UT_CMccDlDataPath* self = UT_CMccDlDataPath::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CMccDlDataPath* UT_CMccDlDataPath::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CMccDlDataPath::~UT_CMccDlDataPath()

    {

    }

// Default constructor

UT_CMccDlDataPath::UT_CMccDlDataPath()

    {

    }

// Second phase construct

void UT_CMccDlDataPath::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CMccDlDataPath::SetupL(  )

    {

    iResources = CMccResourcePoolStub::NewL();

    TMediaId mediaId;

    iSourceStub = static_cast< CMccRtpDataSource* >( MDataSource::NewSourceL( KRtpDataSource, KNullDesC8 ) );

    iRead = CAmrPayloadFormatRead::NewL( iSourceStub );

    iSinkStub = static_cast< CMccRtpDataSink* >(MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 ));

    iDlPath = CMccDlDataPath::NewL(this, iResources, mediaId);

    }

void UT_CMccDlDataPath::Teardown(  )

    {

    delete iDlPath;

    delete iSinkStub;

    delete iRead;

    delete iSourceStub;

    delete iResources;

    REComSession::FinalClose();

    }

void UT_CMccDlDataPath::UT_CMccDlDataPath_NegotiateLL(  )

    {

    MDataSource* dummy( NULL );

    // No sink added, leave with KErrNotReady.

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->NegotiateL( *iSourceStub ), KErrNotReady );

    iDlPath->iState = EStopped;

    iDlPath->AddDataSinkL( iSinkStub );

    // Sink added, should leave with KErrArgument (NULL ptr).

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->NegotiateL( *dummy ), KErrArgument );

    // Sink added, actual source. No leave.

    iDlPath->NegotiateL( *iSourceStub );

    }

void UT_CMccDlDataPath::UT_CMccDlDataPath_BufferFilledLL(  )

    {

    CMMFDescriptorBuffer* buffer = NULL;

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(

    	iDlPath->BufferFilledL(buffer), 

    	KErrNotReady ); // state is no EPlaying

    buffer = CMMFDescriptorBuffer::NewL(10);

    CleanupStack::PushL(buffer);

    iDlPath->iState = EStreaming;

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(iDlPath->BufferFilledL(buffer), KErrArgument);

    buffer->Data().Copy(_L("test"));

    MCC_EUNIT_ASSERT_NO_LEAVE(iDlPath->BufferFilledL(buffer));

    CMMFDescriptorBuffer* buffer2 = CMMFDescriptorBuffer::NewL(10);

    CleanupStack::PushL(buffer2);

    iDlPath->iSourceBuffer = buffer;

    MCC_EUNIT_ASSERT_NO_LEAVE(iDlPath->BufferFilledL(buffer2));

    CleanupStack::PopAndDestroy(buffer2);

    CleanupStack::PopAndDestroy(buffer);

    }

void UT_CMccDlDataPath::UT_CMccDlDataPath_BufferEmptiedLL(  )

    {

    CMMFBuffer* buffer = CMMFDescriptorBuffer::NewL(10);

    CleanupStack::PushL(buffer);

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(

    	iDlPath->BufferEmptiedL(buffer), 

    	KErrNotReady ); // state is no EPlaying

    iDlPath->iState = EStreaming;

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(

    	iDlPath->BufferEmptiedL(buffer), 

    	KErrArgument );

    iDlPath->iSourceBuffer = buffer;

    iDlPath->BufferEmptiedL(buffer);

    iDlPath->iSourceBuffer = NULL;

    CleanupStack::PopAndDestroy(buffer);

    }

void UT_CMccDlDataPath::UT_CMccDlDataPath_PrimeLL(  )

    {

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->PrimeL( 0 ),	KErrNotReady ); // state is not ready   

    iDlPath->iState = EStopped;

    iDlPath->AddDataSinkL( iSinkStub );

    iDlPath->AddDataSourceL( iRead );

    // sourcebuffer is not created

    MCC_EUNIT_ASSERT_NO_LEAVE( iDlPath->PrimeL( 0 ) ); 

    // call ConfigurePayloadFormatL will create source buffer 

    TMccCodecInfo codec;

    codec.iFourCC.Set(TFourCC(' ','A','M','R') );

    codec.iBitrate = 12200;

    codec.iCodecMode = KAmrCodecModeOctetAlign;

    codec.iPtime = 20;

    codec.iMaxPtime = 200;

    codec.iPayloadType = 96;

    codec.iRedundancyCount = 0;

    codec.iEnableDTX = EFalse;

    codec.iRedundantPayload = 0;

    codec.iHwFrameTime = 20;

    codec.iAlgoUsed = 0;

    codec.iPayloadFormatEncoder = KImplUidAmrPayloadFormatEncode;

    codec.iPayloadFormatDecoder = KImplUidAmrPayloadFormatDecode;

    TMccCodecInfoBuffer bufferi( codec );

    iRead->ConfigurePayloadFormatL( bufferi ); 

    iDlPath->iState = EPrimed;   

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->PrimeL( 0 ), KErrArgument ); 

    iDlPath->iState = EStopped;	

    MCC_EUNIT_ASSERT_NO_LEAVE( iDlPath->PrimeL( 0 ) );

    iDlPath->iState = EStopped;	

    MCC_EUNIT_ASSERT_NO_LEAVE( iDlPath->PrimeL( MCC_ENDPOINT_ID( iSinkStub ) ) );

    }

void UT_CMccDlDataPath::UT_CMccDlDataPath_PlayLL(  )

    {

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->PlayL( 0 ), KErrNotReady ); // state is not ready  

    iDlPath->iState = EStopped;

    iDlPath->AddDataSinkL( iSinkStub );

    iDlPath->AddDataSourceL( iSourceStub );

    iDlPath->iState = EStreaming;  

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->PlayL( 0 ), KErrGeneral );

    iDlPath->iState = EPrimed;

    CMMFBuffer* buffer = CMMFDescriptorBuffer::NewL(10);

    CleanupStack::PushL(buffer);

    iDlPath->iSourceBuffer = buffer;

    MCC_EUNIT_ASSERT_NO_LEAVE( iDlPath->PlayL( 0 ) );

    iDlPath->iState = EStreaming;

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->PlayL( 0 ), KErrArgument );

    iDlPath->iSourceBuffer = NULL;

    CleanupStack::PopAndDestroy(buffer);

    }

void UT_CMccDlDataPath::UT_CMccDlDataPath_PauseLL(  )

    {  

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->PauseL( 0 ), KErrNotReady ); // state is not ready 

    iDlPath->iState = EStopped;

    iDlPath->AddDataSinkL( iSinkStub );

    iDlPath->AddDataSourceL( iSourceStub );

    iDlPath->iState = EPrimed;

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->PauseL( 0 ), KErrArgument );

    iDlPath->iState = EStreaming;

    MCC_EUNIT_ASSERT_NO_LEAVE(iDlPath->PauseL( 0 ));

    }

void UT_CMccDlDataPath::UT_CMccDlDataPath_StopLL(  )

    {

    iDlPath->iState = EStopped;

    iDlPath->AddDataSinkL( iSinkStub );

    iDlPath->AddDataSourceL( iSourceStub );

    iDlPath->iState = EStreaming;

    MCC_EUNIT_ASSERT_NO_LEAVE( iDlPath->StopL( 0 ) );

    }

void UT_CMccDlDataPath::UT_CMccDlDataPath_ResumeLL(  )

    {   

    iDlPath->iDataPathCreated = EFalse;   

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->ResumeL( 0 ), KErrNotReady ); // state is not ready 

    iDlPath->iState = EStopped;

    iDlPath->AddDataSinkL( iSinkStub );

    iDlPath->AddDataSourceL( iRead );

    iDlPath->iState = EPaused;

    MCC_EUNIT_ASSERT_NO_LEAVE( iDlPath->ResumeL( 0 ) );

    // call ConfigurePayloadFormatL will create source buffer 

    TMccCodecInfo codec;

    codec.iFourCC.Set(TFourCC(' ','A','M','R') );

    codec.iBitrate = 12200;

    codec.iCodecMode = KAmrCodecModeOctetAlign;

    codec.iPtime = 20;

    codec.iMaxPtime = 200;

    codec.iPayloadType = 96;

    codec.iRedundancyCount = 0;

    codec.iEnableDTX = EFalse;

    codec.iRedundantPayload = 0;

    codec.iHwFrameTime = 20;

    codec.iAlgoUsed = 0;

    codec.iPayloadFormatEncoder = KImplUidAmrPayloadFormatEncode;

    codec.iPayloadFormatDecoder = KImplUidAmrPayloadFormatDecode;

    TMccCodecInfoBuffer bufferi( codec );

    iRead->ConfigurePayloadFormatL( bufferi ); 

    iDlPath->iState = EStreaming;

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iDlPath->ResumeL( 0 ), KErrArgument );

    iDlPath->iState = EPaused;	

    MCC_EUNIT_ASSERT_NO_LEAVE( iDlPath->ResumeL( MCC_ENDPOINT_ID( iSinkStub ) ) );

    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    UT_CMccDlDataPath,

    "Add test suite description here.",

    "UNIT" )

EUNIT_TEST(

    "NegotiateL - test ",

    "CMccDlDataPath",

    "NegotiateL",

    "FUNCTIONALITY",

    SetupL, UT_CMccDlDataPath_NegotiateLL, Teardown)

EUNIT_TEST(

    "BufferFilledL - test ",

    "CMccDlDataPath",

    "BufferFilledL",

    "FUNCTIONALITY",

    SetupL, UT_CMccDlDataPath_BufferFilledLL, Teardown)

EUNIT_TEST(

    "BufferEmptiedL - test ",

    "CMccDlDataPath",

    "BufferEmptiedL",

    "FUNCTIONALITY",

    SetupL, UT_CMccDlDataPath_BufferEmptiedLL, Teardown)

EUNIT_TEST(

    "PrimeL - test ",

    "CMccDlDataPath",

    "PrimeL",

    "FUNCTIONALITY",

    SetupL, UT_CMccDlDataPath_PrimeLL, Teardown)

EUNIT_TEST(

    "PlayL - test ",

    "CMccDlDataPath",

    "PlayL",

    "FUNCTIONALITY",

    SetupL, UT_CMccDlDataPath_PlayLL, Teardown)

EUNIT_TEST(

    "PauseL - test ",

    "CMccDlDataPath",

    "PauseL",

    "FUNCTIONALITY",

    SetupL, UT_CMccDlDataPath_PauseLL, Teardown)

EUNIT_TEST(

    "StopL - test ",

    "CMccDlDataPath",

    "StopL",

    "FUNCTIONALITY",

    SetupL, UT_CMccDlDataPath_StopLL, Teardown)

EUNIT_TEST(

    "ResumeL - test ",

    "CMccDlDataPath",

    "ResumeL",

    "FUNCTIONALITY",

    SetupL, UT_CMccDlDataPath_ResumeLL, Teardown)

EUNIT_END_TEST_TABLE

//  END OF FILE