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

//  EXTERNAL INCLUDES
#include <digia/eunit/EUnitMacros.h>
#include <mmf/server/mmfvideoframebuffer.h>


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

#include "mccunittestmacros.h"

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

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

    return self;
    }

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

    self->ConstructL();

    return self;
    }

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

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

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

//  METHODS



void UT_CMccDataPathBase::SetupL(  )
    {
    iResources = CMccResourcePoolStub::NewL();
    
  	TMediaId mediaId;
    iUlPath = CMccUlDataPath::NewL(this, iResources, mediaId);
    iSourceStub = static_cast< CMccRtpDataSource* >( MDataSource::NewSourceL( KRtpDataSource, KNullDesC8 ) );
    iSinkStub = static_cast< CMccRtpDataSink* >(MDataSink::NewSinkL( KRtpDataSink, KNullDesC8 ));
    
    }

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

void UT_CMccDataPathBase::UT_CMccDataPathBase_ChangeDataPathTransferState()
    {
  
    TTransferState state = ENeedSourceData;
    iUlPath->iTransferState = EWaitSource;
    EUNIT_ASSERT(! iUlPath->ChangeDataPathTransferState( state ) );
    
    // Change is allowed if handling failure situation
    EUNIT_ASSERT( iUlPath->ChangeDataPathTransferState( state, ETrue ) );
    
    
    iUlPath->iState = EStopped;
    iUlPath->iTransferState = ESendDataToSink;
    EUNIT_ASSERT( iUlPath->ChangeDataPathTransferState( state ) );

    }
    
void UT_CMccDataPathBase::UT_CMccDataPathBase_ConstructSinkSource()
    {
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->CMccDataPathBase::ConstructSinkL(_L8("sink")), KErrNotSupported );    
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->CMccDataPathBase::ConstructSourceL(_L8("source")), KErrNotSupported );    
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_IsBufferSupportedL()
    {
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->IsBufferSupportedL( NULL ), KErrArgument ); 
    
    CMMFDescriptorBuffer* buffer = CMMFDescriptorBuffer::NewL(10);
    CleanupStack::PushL( buffer );
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->IsBufferSupportedL( buffer ) );
    CleanupStack::PopAndDestroy( buffer );
    
    CMMFYUVBuffer* yuvBuf = CMMFYUVBuffer::NewL();  
    CleanupStack::PushL( yuvBuf ); 
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->IsBufferSupportedL( yuvBuf ), KErrNotSupported ); 
    CleanupStack::PopAndDestroy( yuvBuf );
    
    CMMFDataBuffer* databuf = CMMFDataBuffer::NewL( 10 );         
    CleanupStack::PushL( databuf );
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->IsBufferSupportedL( databuf ) );
    CleanupStack::PopAndDestroy();
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_CreateCompleteCallBackL()
    {
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->CreateCompleteCallBackL(), KErrArgument );
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->CMccDataPathBase::AddDataSinkL(iSinkStub) );
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->CreateCompleteCallBackL() );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_CopyBuffer()
    {
    CMMFDataBuffer* desbuf = CMMFDataBuffer::NewL( 10 );         
    CleanupStack::PushL( desbuf );
    
    CMMFDataBuffer* oribuf = CMMFDataBuffer::NewL( 10 );         
    CleanupStack::PushL( oribuf );
    
    iUlPath->CopyBuffer( NULL, NULL );
    iUlPath->CopyBuffer( desbuf, NULL );
    iUlPath->CopyBuffer( NULL, oribuf );
    iUlPath->CopyBuffer( desbuf, oribuf );
    iUlPath->CopyBuffer( desbuf, desbuf );

    CleanupStack::PopAndDestroy( oribuf );

    CleanupStack::PopAndDestroy( desbuf );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_AddDataSinkLL(  )
    {
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->CMccDataPathBase::AddDataSinkL(NULL), KErrArgument);
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->CMccDataPathBase::AddDataSinkL(iSinkStub) );
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->CMccDataPathBase::AddDataSourceL(iSourceStub) );
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->CMccDataPathBase::AddDataSinkL(iSinkStub) );
    
    iUlPath->iState = EPaused;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->CMccDataPathBase::AddDataSinkL(iSinkStub), KErrNotReady );

    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_AddDataSourceLL(  )
    {    
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->CMccDataPathBase::AddDataSourceL(NULL), KErrArgument);

    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->CMccDataPathBase::AddDataSourceL(iSourceStub) );
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->CMccDataPathBase::AddDataSinkL(iSinkStub) );
    MCC_EUNIT_ASSERT_NO_LEAVE( iUlPath->CMccDataPathBase::AddDataSourceL(iSourceStub) );
    
    iUlPath->iState = EPaused;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE( iUlPath->CMccDataPathBase::AddDataSourceL(iSourceStub), KErrNotReady );

    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_EndOfDataL(  )
    {
    iUlPath->CMccDataPathBase::AddDataSinkL(iSinkStub);
    iUlPath->CMccDataPathBase::CreateCompleteCallBackL();
    
    iUlPath->CMccDataPathBase::EndOfData();
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_PrimeLL(  )
    {
    EUNIT_ASSERT( ETrue );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_PlayLL(  )
    {
    EUNIT_ASSERT( ETrue );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_PauseLL(  )
    {
    EUNIT_ASSERT( ETrue );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_StopLL(  )
    {
    EUNIT_ASSERT( ETrue );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_ResumeLL(  )
    {
    EUNIT_ASSERT( ETrue );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_CreateSinkBufferLL(  )
    {
    TMediaId mediaId;
    TBool bufRef;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(iUlPath->CreateSinkBufferL(mediaId,bufRef) ,KErrNotSupported);
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_CreateSourceBufferLL(  )
    {
    TMediaId mediaId;
    TBool bufRef;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(iUlPath->CreateSourceBufferL(mediaId,bufRef) ,KErrNotSupported);
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_CanCreateSinkBufferL(  )
    {
    EUNIT_ASSERT( !iUlPath->CMccDataPathBase::CanCreateSinkBuffer() );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_CanCreateSourceBufferL(  )
    {
    EUNIT_ASSERT( !iUlPath->CMccDataPathBase::CanCreateSourceBuffer() );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_EmptyBufferLL(  )
    {
    CMMFBuffer* buffer = NULL;
    MDataSource* source = NULL;
    TMediaId mediaId;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(
    	iUlPath->CMccDataPathBase::EmptyBufferL(buffer,source,mediaId), 
    	KErrNotSupported);
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_FillBufferLL(  )
    {
    CMMFBuffer* buffer = NULL;
    MDataSink* sink = NULL;
    TMediaId mediaId;
    MCC_EUNIT_ASSERT_SPECIFIC_LEAVE(
    	iUlPath->CMccDataPathBase::FillBufferL(buffer,sink,mediaId), 
    	KErrNotSupported);
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_SinkDataTypeCodeL(  )
    {
    TMediaId mediaId;
    
    // Supported media types
    mediaId.iMediaType = KUidMediaTypeVideo;
    const KTestFourCCVal1 = 0x100000;
    iUlPath->iSinkFourCC = TFourCC( KTestFourCCVal1 );
    EUNIT_ASSERT( iUlPath->SinkDataTypeCode( mediaId ) == TFourCC( KTestFourCCVal1 ) );
    const KTestFourCCVal2 = 0x200000;
    iUlPath->iSinkFourCC = TFourCC( KTestFourCCVal2 );
    mediaId.iMediaType = KUidMediaTypeAudio;
    EUNIT_ASSERT( iUlPath->SinkDataTypeCode( mediaId ) == TFourCC( KTestFourCCVal2 ) );
    
    // Unsupported media type
    mediaId.iMediaType = KUidMediaTypeMidi;
    EUNIT_ASSERT( iUlPath->SinkDataTypeCode( mediaId ) == TFourCC( KFourCCNULL ) );
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_SourceDataTypeCodeL(  )
    {
    TMediaId mediaId;
    
    // Supported media types
    mediaId.iMediaType = KUidMediaTypeVideo;
    const KTestFourCCVal1 = 0x100000;
    iUlPath->iSourceFourCC = TFourCC( KTestFourCCVal1 );
    EUNIT_ASSERT( iUlPath->SourceDataTypeCode( mediaId ) == TFourCC( KTestFourCCVal1 ) );
    const KTestFourCCVal2 = 0x200000;
    iUlPath->iSourceFourCC = TFourCC( KTestFourCCVal2 );
    mediaId.iMediaType = KUidMediaTypeAudio;
    EUNIT_ASSERT( iUlPath->SourceDataTypeCode( mediaId ) == TFourCC( KTestFourCCVal2 ) );
    
    // Unsupported media type
    mediaId.iMediaType = KUidMediaTypeMidi;
    EUNIT_ASSERT( iUlPath->SourceDataTypeCode( mediaId ) == TFourCC( KFourCCNULL ) );
    
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_SetSinkDataTypeCodeL(  )
    {
    TMediaId mediaId;
    mediaId.iMediaType = KRtpDataSource;
    EUNIT_ASSERT_EQUALS(
    	iUlPath->CMccDataPathBase::SetSinkDataTypeCode(TFourCC(),mediaId), 
    	KErrNotSupported);
    iUlPath->iMediaId.iMediaType = KRtpDataSource;
    EUNIT_ASSERT_EQUALS(
    	iUlPath->CMccDataPathBase::SetSinkDataTypeCode(TFourCC(),mediaId), 
    	KErrNone);
    }

void UT_CMccDataPathBase::UT_CMccDataPathBase_SetSourceDataTypeCodeL(  )
    {
    TMediaId mediaId;
    mediaId.iMediaType = KRtpDataSource;
    EUNIT_ASSERT_EQUALS(
    	iUlPath->CMccDataPathBase::SetSourceDataTypeCode(TFourCC(),mediaId), 
    	KErrNotSupported);
    iUlPath->iMediaId.iMediaType = KRtpDataSource;
    EUNIT_ASSERT_EQUALS(
    	iUlPath->CMccDataPathBase::SetSourceDataTypeCode(TFourCC(),mediaId), 
    	KErrNone);
    }

//  TEST TABLE

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

EUNIT_TEST(
    "ChangeDataPathTransferState - test ",
    "CMccDataPathBase",
    "ChangeDataPathTransferState",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_ChangeDataPathTransferState, Teardown)

EUNIT_TEST(
    "ConstructSinkSource - test ",
    "CMccDataPathBase",
    "ConstructSinkSource",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_ConstructSinkSource, Teardown)

EUNIT_TEST(
    "IsBufferSupportedL - test ",
    "CMccDataPathBase",
    "IsBufferSupportedL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_IsBufferSupportedL, Teardown)

EUNIT_TEST(
    "CreateCompleteCallBackL - test ",
    "CMccDataPathBase",
    "CreateCompleteCallBackL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_CreateCompleteCallBackL, Teardown)



EUNIT_TEST(
    "CopyBuffer - test ",
    "CMccDataPathBase",
    "CopyBuffer",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_CopyBuffer, Teardown)

EUNIT_TEST(
    "AddDataSinkL - test ",
    "CMccDataPathBase",
    "AddDataSinkL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_AddDataSinkLL, Teardown)

EUNIT_TEST(
    "AddDataSourceL - test ",
    "CMccDataPathBase",
    "AddDataSourceL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_AddDataSourceLL, Teardown)

EUNIT_TEST(
    "EndOfData - test ",
    "CMccDataPathBase",
    "EndOfData",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_EndOfDataL, Teardown)

EUNIT_TEST(
    "PrimeL - test ",
    "CMccDataPathBase",
    "PrimeL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_PrimeLL, Teardown)

EUNIT_TEST(
    "PlayL - test ",
    "CMccDataPathBase",
    "PlayL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_PlayLL, Teardown)

EUNIT_TEST(
    "PauseL - test ",
    "CMccDataPathBase",
    "PauseL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_PauseLL, Teardown)

EUNIT_TEST(
    "StopL - test ",
    "CMccDataPathBase",
    "StopL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_StopLL, Teardown)

EUNIT_TEST(
    "ResumeL - test ",
    "CMccDataPathBase",
    "ResumeL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_ResumeLL, Teardown)

EUNIT_TEST(
    "CreateSinkBufferL - test ",
    "CMccDataPathBase",
    "CreateSinkBufferL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_CreateSinkBufferLL, Teardown)

EUNIT_TEST(
    "CreateSourceBufferL - test ",
    "CMccDataPathBase",
    "CreateSourceBufferL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_CreateSourceBufferLL, Teardown)

EUNIT_TEST(
    "CanCreateSinkBuffer - test ",
    "CMccDataPathBase",
    "CanCreateSinkBuffer",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_CanCreateSinkBufferL, Teardown)

EUNIT_TEST(
    "CanCreateSourceBuffer - test ",
    "CMccDataPathBase",
    "CanCreateSourceBuffer",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_CanCreateSourceBufferL, Teardown)

EUNIT_TEST(
    "EmptyBufferL - test ",
    "CMccDataPathBase",
    "EmptyBufferL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_EmptyBufferLL, Teardown)

EUNIT_TEST(
    "FillBufferL - test ",
    "CMccDataPathBase",
    "FillBufferL",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_FillBufferLL, Teardown)

EUNIT_TEST(
    "SinkDataTypeCode - test ",
    "CMccDataPathBase",
    "SinkDataTypeCode",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_SinkDataTypeCodeL, Teardown)

EUNIT_TEST(
    "SourceDataTypeCode - test ",
    "CMccDataPathBase",
    "SourceDataTypeCode",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_SourceDataTypeCodeL, Teardown)

EUNIT_TEST(
    "SetSinkDataTypeCode - test ",
    "CMccDataPathBase",
    "SetSinkDataTypeCode",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_SetSinkDataTypeCodeL, Teardown)

EUNIT_TEST(
    "SetSourceDataTypeCode - test ",
    "CMccDataPathBase",
    "SetSourceDataTypeCode",
    "FUNCTIONALITY",
    SetupL, UT_CMccDataPathBase_SetSourceDataTypeCodeL, Teardown)


EUNIT_END_TEST_TABLE

//  END OF FILE