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

//  EXTERNAL INCLUDES
#include <digia/eunit/eunitmacros.h>


//  INTERNAL INCLUDES
#include "mcculdatapath.h"
#include "MccRtpDatasource.h"
#include "MccRtpDataSink.h"
#include "mccresourcepool_stub.h"
#include "mccuids.hrh"
#include "mccinternaldef.h"
#include "AmrPayloadFormatWrite.h"

#include "mccunittestmacros.h"


const TUid KRtpDataSource            =  { KImplUidRtpDataSource   }; 
const TUid KRtpDataSink              =  { KImplUidRtpDataSink     };


// CONSTRUCTION
UT_CMccUlDataPath* UT_CMccUlDataPath::NewL()
    {
    UT_CMccUlDataPath* self = UT_CMccUlDataPath::NewLC();
    CleanupStack::Pop();

    return self;
    }

UT_CMccUlDataPath* UT_CMccUlDataPath::NewLC()
    {
    UT_CMccUlDataPath* self = new( ELeave ) UT_CMccUlDataPath();
    CleanupStack::PushL( self );

    self->ConstructL();

    return self;
    }

// Destructor (virtual by CBase)
UT_CMccUlDataPath::~UT_CMccUlDataPath()
    {
    }

// Default constructor
UT_CMccUlDataPath::UT_CMccUlDataPath()
    {
    }

// Second phase construct
void UT_CMccUlDataPath::ConstructL()
    {
    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
    // It generates the test case table.
    CEUnitTestSuiteClass::ConstructL();
    }

//  METHODS



void UT_CMccUlDataPath::SetupL(  )
    {
    iResources = CMccResourcePoolStub::NewL();
    
    TMediaId mediaId;
    iSourceStub = static_cast< CMccRtpDataSource* >( MDataSource::NewSourceL( KRtpDataSource, KNullDesC8 ) );
    iSinkStub = static_cast< CMccRtpDataSink* >(MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 ));
    iWrite = CAmrPayloadFormatWrite::NewL( iSinkStub );

    iUlPath = CMccUlDataPath::NewL(this, iResources, mediaId);
    }

void UT_CMccUlDataPath::Teardown(  )
    {
    delete iUlPath;
    delete iWrite;
    delete iSinkStub;
    delete iSourceStub;
    delete iResources;
    REComSession::FinalClose();
    }

void UT_CMccUlDataPath::UT_CMccUlDataPath_NegotiateLL()
    {
    MDataSink* sink = NULL;
    // No source added, not ready
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->NegotiateL( *sink ), KErrNotReady );
    
    iUlPath->AddDataSourceL( iSourceStub );
    // Source added, NULL ptr, argument
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->NegotiateL( *sink ), KErrArgument );
    
    // Actual sink, no leave
    iUlPath->iState = EStopped;
    iUlPath->NegotiateL( *iSinkStub );
    }

void UT_CMccUlDataPath::UT_CMccUlDataPath_BufferEmptiedLL(  )
    {
    CMMFBuffer* buffer = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(iUlPath->BufferEmptiedL(buffer), KErrArgument);
    CMMFDescriptorBuffer* dataBuffer = CMMFDescriptorBuffer::NewL(10);
    CleanupStack::PushL(dataBuffer);
    dataBuffer->Data().Copy(_L("test"));
    iUlPath->iState = EPrimed;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(iUlPath->BufferEmptiedL(static_cast<CMMFBuffer*>(dataBuffer)), KErrNotReady);
    iUlPath->iState = EStreaming;
    iUlPath->BufferEmptiedL(static_cast<CMMFBuffer*>(dataBuffer));
    CleanupStack::PopAndDestroy(dataBuffer);
    }

void UT_CMccUlDataPath::UT_CMccUlDataPath_BufferFilledLL(  )
    {
    CMMFBuffer* buffer = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(iUlPath->BufferFilledL(buffer), KErrNotReady);
    iUlPath->iState = EStreaming;
    iUlPath->BufferFilledL(buffer);
    CMMFDescriptorBuffer* dataBuffer = CMMFDescriptorBuffer::NewL(10);
    CleanupStack::PushL(dataBuffer);
    CMMFBuffer* sinkBuffer = CMMFDescriptorBuffer::NewL(10);
    CleanupStack::PushL(sinkBuffer);
    iUlPath->iSinkBuffer = sinkBuffer;
    iUlPath->BufferFilledL(static_cast<CMMFBuffer*>(dataBuffer));
    dataBuffer->Data().Copy(_L("test"));
    iUlPath->BufferFilledL(static_cast<CMMFBuffer*>(dataBuffer));
    CleanupStack::PopAndDestroy(sinkBuffer);
    CleanupStack::PopAndDestroy(dataBuffer);
    }

void UT_CMccUlDataPath::UT_CMccUlDataPath_PrimeLL(  )
    {
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PrimeL( 0 ), KErrNotReady ); // state is not ready   
    
    iUlPath->iState = EStopped;
    iUlPath->AddDataSinkL( iWrite );
    iUlPath->AddDataSourceL( iSourceStub );
    
    iUlPath->iState = EPrimed;
    iUlPath->iMediaId.iMediaType = KUidMediaTypeAudio;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PrimeL( 0 ), KErrArgument ); 
    	
    iUlPath->iState = EStopped;
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->PrimeL( 0 ) );
    
    iUlPath->iState = EStopped;	
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->PrimeL( MCC_ENDPOINT_ID( iSourceStub ) ) );
    
    iUlPath->iDataSink = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PrimeL( 0 ), KErrGeneral );

    iUlPath->iDataSource = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PrimeL( 0 ), KErrGeneral );

    }

void UT_CMccUlDataPath::UT_CMccUlDataPath_PlayLL(  )
    {
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PlayL( 0 ), KErrNotReady ); // state is not ready  
  
    iUlPath->iState = EStopped;
    iUlPath->AddDataSinkL( iSinkStub );
    iUlPath->AddDataSourceL( iSourceStub );
    
    iUlPath->iState = EStreaming;  
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PlayL( 0 ), KErrGeneral );
    
    iUlPath->iState = EPrimed;
    CMMFBuffer* buffer = CMMFDescriptorBuffer::NewL(10);
    CleanupStack::PushL(buffer);
    iUlPath->iSinkBuffer = buffer;
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->PlayL( 0 ) );
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->PlayL( 3 ) );

    iUlPath->iState = EStreaming;  
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PlayL( 0 ), KErrArgument );
    
    iUlPath->iSinkBuffer = NULL;
    CleanupStack::PopAndDestroy(buffer);
    
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PlayL( 0 ), KErrGeneral );

    iUlPath->iDataSink = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PlayL( 0 ), KErrGeneral );

    iUlPath->iDataSource = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PlayL( 0 ), KErrGeneral );

    }

void UT_CMccUlDataPath::UT_CMccUlDataPath_PauseLL(  )
    {
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PauseL( 0 ), KErrNotReady ); // state is not ready 
    	
    iUlPath->iState = EStopped;
    iUlPath->AddDataSinkL( iSinkStub );
    iUlPath->AddDataSourceL( iSourceStub );
    
    iUlPath->iState = EPrimed;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PauseL( 0 ), KErrArgument );

    iUlPath->iState = EStreaming;
    MCC_EUNIT_ASSERT_NO_LEAVE(iUlPath->PauseL( 0 ));
    
    iUlPath->iDataSink = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PauseL( 0 ),  KErrGeneral );

    iUlPath->iDataSource = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->PauseL( 0 ),  KErrGeneral );

    }

void UT_CMccUlDataPath::UT_CMccUlDataPath_StopLL(  )
    {
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(iUlPath->StopL( 0 ), KErrNotReady ); // state is not ready 
    	
    iUlPath->iState = EStopped;
    iUlPath->AddDataSinkL( iWrite );
    iUlPath->AddDataSourceL( iSourceStub );
    
    iUlPath->iState = EStopped;
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->StopL( 0 ) );
    
    iUlPath->iState = EStreaming;
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->StopL( 0 ) );
    
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->StopL( 3 ) );
    
    iUlPath->iDataSink = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->StopL( 3 ),  KErrGeneral );

    iUlPath->iDataSource = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->StopL( 3 ),  KErrGeneral );

    }

void UT_CMccUlDataPath::UT_CMccUlDataPath_ResumeLL(  )
    {
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(iUlPath->ResumeL( 0 ), KErrNotReady ); // state is not ready 
    	
    iUlPath->iState = EStopped;
    iUlPath->AddDataSinkL( iWrite );
    iUlPath->AddDataSourceL( iSourceStub );
    
    iUlPath->iState = EStreaming;
    // media type not KUidMediaTypeAudio
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->ResumeL( 0 ), KErrArgument );

    iUlPath->iState = EPaused;

    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->ResumeL( 0 ), KErrNotSupported );
    
    iUlPath->iState = EPaused;	    
    iUlPath->iMediaId.iMediaType = KUidMediaTypeAudio;

    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->ResumeL( MCC_ENDPOINT_ID( iSourceStub ) ) );
    
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->ResumeL( 0 ) );

    iUlPath->iDataSink = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->ResumeL( 0 ), KErrGeneral );

    iUlPath->iDataSource = NULL;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->ResumeL( 0 ), KErrGeneral );
    }

void UT_CMccUlDataPath::UT_CMccUlDataPath_RunLL()
    {
    iUlPath->iTransferState = EWaitSink;
    iUlPath->iState = EStopped;
    iUlPath->RunL();
    
    iUlPath->iState = EPrimed;
    iUlPath->RunL();
    
    iUlPath->iState = EPaused;
    iUlPath->RunL();
    
    iUlPath->iState = EStreaming;
    iUlPath->iTransferState = EWaitSink;
    iUlPath->RunL();
    iUlPath->iTransferState = EWaitSource;
    iUlPath->RunL();
    iUlPath->iTransferState = ENeedSourceData;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->RunL(), KErrNotReady );
    iUlPath->iTransferState = ESendDataToSink;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->RunL(), KErrNotReady );
    
    iUlPath->iState = EStopped;
    iUlPath->AddDataSinkL( iWrite );
    iUlPath->AddDataSourceL( iSourceStub );
    iUlPath->iState = EStreaming;
    iUlPath->iTransferState = EEndOfData;
    iUlPath->RunL();
    iUlPath->iTransferState = static_cast<TTransferState>( 1000 );
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->RunL(), KErrArgument );
    
    iUlPath->iState = static_cast<TDataPathState>( 1000 );
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->RunL(), KErrArgument );
    }
  
void UT_CMccUlDataPath::UT_CMccUlDataPath_EmptySinkBuffer()
    {
    iUlPath->iDataSink = iWrite;
    CMMFDataBuffer* buf = CMMFDataBuffer::NewL(10);
    CleanupStack::PushL( buf );
    iUlPath->iSinkBuffer = buf;
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->EmptySinkBufferL() );
    CleanupStack::PopAndDestroy( buf );
    
    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(
    UT_CMccUlDataPath,
    "Add test suite description here.",
    "UNIT" )

EUNIT_TEST(
    "NegotiateL - test ",
    "CMccUlDataPath",
    "NegotiateL",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_NegotiateLL, Teardown)

EUNIT_TEST(
    "BufferEmptiedL - test ",
    "CMccUlDataPath",
    "BufferEmptiedL",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_BufferEmptiedLL, Teardown)

EUNIT_TEST(
    "BufferFilledL - test ",
    "CMccUlDataPath",
    "BufferFilledL",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_BufferFilledLL, Teardown)

EUNIT_TEST(
    "PrimeL - test ",
    "CMccUlDataPath",
    "PrimeL",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_PrimeLL, Teardown)

EUNIT_TEST(
    "PlayL - test ",
    "CMccUlDataPath",
    "PlayL",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_PlayLL, Teardown)

EUNIT_TEST(
    "PauseL - test ",
    "CMccUlDataPath",
    "PauseL",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_PauseLL, Teardown)

EUNIT_TEST(
    "StopL - test ",
    "CMccUlDataPath",
    "StopL",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_StopLL, Teardown)

EUNIT_TEST(
    "ResumeL - test ",
    "CMccUlDataPath",
    "ResumeL",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_ResumeLL, Teardown)

EUNIT_TEST(
    "RunL - test ",
    "CMccUlDataPath",
    "RunL",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_RunLL, Teardown)
 
EUNIT_TEST(
    "EmptySinkBuffer - test ",
    "CMccUlDataPath",
    "EmptySinkBuffer",
    "FUNCTIONALITY",
    SetupL, UT_CMccUlDataPath_EmptySinkBuffer, Teardown)
 
   
EUNIT_END_TEST_TABLE

//  END OF FILE