/*

* Copyright (c) 2002 - 2007 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:   ?Description

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "UsbObexClassControllerTest.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

const TUid KCSrcsInterfaceUid = {0x101F7C8C};

const TInt KObexNumInterfaces = 2;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

// ============================ MEMBER FUNCTIONS ===============================

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

// CUsbObexClassControllerTest::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

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

//

void CUsbObexClassControllerTest::Delete() 

    {

    }

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

// CUsbObexClassControllerTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CUsbObexClassControllerTest::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        //ADD NEW ENTRY HERE

        // [test cases entries] - Do not remove

		ENTRY( "ExecuteApiTest", CUsbObexClassControllerTest::ExecuteApiTest ),

        ENTRY( "ExecuteModuleTest", CUsbObexClassControllerTest::ExecuteModuleTest ),

        ENTRY( "ExecuteBranchTest", CUsbObexClassControllerTest::ExecuteBranchTest ),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CUsbObexClassControllerTest::ExecuteApiTest

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

//

TInt CUsbObexClassControllerTest::ExecuteApiTest( CStifItemParser& aItem )

    {

	STIF_LOG( "[STIF_LOG] >>>ExecuteApiTest" );

	TInt res;

    TUsbObexClassControllerTestResult testResult = ETestCaseFailed;

    TPtrC apiTestName( KNullDesC );

	res = aItem.GetString( _L( "ExecuteApiTest" ), apiTestName );   

    if ( res != KErrNone )

        {

        iLog -> Log( _L( "GetString failed with value: %d" ), res );

        return res;

        }

	TRAP( res, DoExecuteApiTestL( apiTestName, testResult ) );

    if ( res != KErrNone )

        {

        iLog -> Log( _L( "DoExecuteApiTestL error: %d"), res );

        return res;

        }

    STIF_ASSERT_EQUALS( ETestCasePassed, testResult );

    STIF_LOG( "[STIF_LOG] Test case passed" );

	STIF_LOG( "[STIF_LOG] <<<ExecuteApiTest" );

    return KErrNone;

    }

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

// CUsbObexClassControllerTest::DoExecuteApiTestL

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

//

void CUsbObexClassControllerTest::DoExecuteApiTestL( TPtrC aApiTestName, TUsbObexClassControllerTestResult& aTestResult )

    {

	STIF_LOG( "[STIF_LOG] >>>DoExecuteApiTestL" );

    if ( !aApiTestName.Compare( _L( "ExampleApiTest" ) ) )

        {

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        ExampleApiTestL( aTestResult );

        }

    else if ( !aApiTestName.Compare( _L( "InitializationTest" ) ) )

    	{

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        InitializationTestL( aTestResult );    	

    	}

    else if ( !aApiTestName.Compare( _L( "StartTest" ) ) )

    	{

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        StartTestL( aTestResult );    	

    	}

    else if ( !aApiTestName.Compare( _L( "StopTest" ) ) )

    	{

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        StopTestL( aTestResult );    	

    	}

    else if ( !aApiTestName.Compare( _L( "InterfaceInfoTest" ) ) )

    	{

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        InterfaceInfoTestL( aTestResult );    	

    	}

    else if ( !aApiTestName.Compare( _L( "InterfaceLengthInfoTest" ) ) )

    	{

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        InterfaceLengthInfoTestL( aTestResult );    	

    	}

    else if ( !aApiTestName.Compare( _L( "NumberOfInterfacesInfoTest" ) ) )

    	{

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        NumberOfInterfacesInfoTestL( aTestResult );    	

    	}

    else if ( !aApiTestName.Compare( _L( "StartupPriorityInfoTest" ) ) )

    	{

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        StartupPriorityInfoTestL( aTestResult );    	

    	}

    else if ( !aApiTestName.Compare( _L( "StateInfoTest" ) ) )

    	{

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        StateInfoTestL( aTestResult );    	

    	}

    else if ( !aApiTestName.Compare( _L( "OwnerTest" ) ) )

    	{

        STIF_LOG( "[STIF_LOG] Api test type: ExampleApiTest" );

        OwnerTestL( aTestResult );    	

    	}

    else

        {

        STIF_LOG( "[STIF_LOG] Api test type: not found" );

        User::Leave( KErrNotFound );

        }

	STIF_LOG( "[STIF_LOG] <<<DoExecuteApiTestL" );

    }

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

// CUsbObexClassControllerTest::ExecuteApiTest

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

//

void CUsbObexClassControllerTest::ExampleApiTestL( TUsbObexClassControllerTestResult& aTestResult )

    {

	STIF_LOG( "[STIF_LOG] >>>ExampleApiTestL" );

    aTestResult = ETestCasePassed;

	STIF_LOG( "[STIF_LOG] <<<ExampleApiTestL" );

    }

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

// CUsbObexClassControllerTest::ExecuteModuleTest

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

//

TInt CUsbObexClassControllerTest::ExecuteModuleTest( CStifItemParser& aItem )

    {

	STIF_LOG( "[STIF_LOG] >>>ExecuteModuleTest" );

    TInt res;

    TUsbObexClassControllerTestResult testResult;

    TPtrC moduleTestName( KNullDesC );

    res = aItem.GetString( _L( "ExecuteModuleTest" ), moduleTestName );   

    if ( res != KErrNone )

        {

        iLog -> Log( _L( "GetString failed with value: %d" ), res );

        return res;

        }

    TRAP( res, DoExecuteModuleTestL( moduleTestName, testResult ) );

    if ( res != KErrNone )

        {

        iLog -> Log( _L( "DoExecuteModuleTestL error: %d"), res );

        return res;

        }

    STIF_ASSERT_EQUALS( ETestCasePassed, testResult );

    STIF_LOG( "[STIF_LOG] Test case passed" );

	STIF_LOG( "[STIF_LOG] <<<ExecuteModuleTest" );

    return KErrNone;

    }		

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

// CUsbObexClassControllerTest::DoExecuteModuleTestL

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

//

void CUsbObexClassControllerTest::DoExecuteModuleTestL( TPtrC aModuleTestName, TUsbObexClassControllerTestResult& aTestResult )

    {

	STIF_LOG( "[STIF_LOG] >>>DoExecuteModuleTestL" );

    if ( !aModuleTestName.Compare( _L( "ExampleModuleTest" ) ) )

        {

        STIF_LOG( "[STIF_LOG] Module test type: ExampleModuleTest" );

        ExampleModuleTestL( aTestResult );

        }

    else

        {

        STIF_LOG( "[STIF_LOG] Module test type: not found" );

        User::Leave( KErrNotFound );

        }

	STIF_LOG( "[STIF_LOG] <<<DoExecuteModuleTestL" );

    }

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

// CUsbObexClassControllerTest::ExampleModuleTestL

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

//

void CUsbObexClassControllerTest::ExampleModuleTestL( TUsbObexClassControllerTestResult& aTestResult )

    {

	STIF_LOG( "[STIF_LOG] >>>ExampleModuleTestL" );

    aTestResult = ETestCasePassed;

	STIF_LOG( "[STIF_LOG] <<<ExampleModuleTestL" );

    }

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

// CUsbObexClassControllerTest::ExecuteBranchTest

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

//

TInt CUsbObexClassControllerTest::ExecuteBranchTest( CStifItemParser& aItem )

    {

	STIF_LOG( "[STIF_LOG] >>>ExecuteBranchTest" );

    TInt res;

    TUsbObexClassControllerTestResult testResult;

    TPtrC branchTestName( KNullDesC );

    res = aItem.GetString( _L( "ExecuteBranchTest" ), branchTestName );   

    if ( res != KErrNone )

        {

        iLog -> Log( _L( "GetString failed with value: %d" ), res );

        return res;

        }

    TRAP( res, DoExecuteBranchTestL( branchTestName, testResult ) );

    if ( res != KErrNone )

        {

        iLog -> Log( _L( "DoExecuteBranchTestL error: %d"), res );

        return res;

        }

    STIF_ASSERT_EQUALS( ETestCasePassed, testResult );

    STIF_LOG( "[STIF_LOG] Test case passed" );

	STIF_LOG( "[STIF_LOG] <<<ExecuteBranchTest" );

    return KErrNone;

    }

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

// CUsbObexClassControllerTest::DoExecuteBranchTestL

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

//

void CUsbObexClassControllerTest::DoExecuteBranchTestL( TPtrC aBranchTestName, TUsbObexClassControllerTestResult& aTestResult )

    {

	STIF_LOG( "[STIF_LOG] >>>DoExecuteBranchTestL" );

    if ( !aBranchTestName.Compare( _L( "ExampleBranchTest" ) ) )

        {

        STIF_LOG( "[STIF_LOG] Branch test type: ExampleBranchTest" );

        ExampleBranchTestL( aTestResult );

        }

    else

        {

        STIF_LOG( "[STIF_LOG] Branch test type: not found" );

        User::Leave( KErrNotFound );

        }

	STIF_LOG( "[STIF_LOG] <<<DoExecuteBranchTestL" );

    }	

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

// CUsbObexClassControllerTest::ExampleBranchTestL

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

//

void CUsbObexClassControllerTest::ExampleBranchTestL( TUsbObexClassControllerTestResult& aTestResult )

    {

	STIF_LOG( "[STIF_LOG] >>>ExampleBranchTestL" );

    aTestResult = ETestCasePassed;

	STIF_LOG( "[STIF_LOG] <<<ExampleBranchTestL" );

	}

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

// CUsbObexClassControllerTest::InitializationTestL

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

//

TInt CUsbObexClassControllerTest::InitializationTestL( TUsbObexClassControllerTestResult& aTestResult )

    {    

    InitializeTestObjectL();

    STIF_ASSERT_NOT_NULL( iUsbClassControllerPlugIn );

    DeleteTestObject();    

    // Case was executed

    iLog->Log( _L("Test Case Passed"));

    aTestResult = ETestCasePassed;

    return KErrNone;

    }

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

// CUsbObexClassControllerTest::StartTestL

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

//

TInt CUsbObexClassControllerTest::StartTestL( TUsbObexClassControllerTestResult& aTestResult )

    {

    iUsbServiceState = EUsbServiceStarted;

    InitializeTestObjectL();

    CUSBObexApiTestActiveObject* activeTestObject = 

            CUSBObexApiTestActiveObject::NewL( iLog, iUsbClassControllerPlugIn );

    activeTestObject -> Start();

    CActiveScheduler::Start();

    iLog->Log( _L("UsbServiceState = %d, expected %d"), 

                        iUsbServiceState, iUsbClassControllerPlugIn -> State());

    STIF_ASSERT_EQUALS( iUsbServiceState, iUsbClassControllerPlugIn -> State() );    

    DeleteTestObject();

    activeTestObject -> Cancel();

    // Case was executed

    iLog->Log( _L("Test Case Passed"));

    aTestResult = ETestCasePassed;

    return KErrNone;

    }

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

// CUsbObexClassControllerTest::StopTestL

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

//

TInt CUsbObexClassControllerTest::StopTestL( TUsbObexClassControllerTestResult& aTestResult )

    {

    iUsbServiceState = EUsbServiceIdle;

    InitializeTestObjectL();

    CUSBObexApiTestActiveObject* activeTestObject = 

            CUSBObexApiTestActiveObject::NewL( iLog, iUsbClassControllerPlugIn );

    activeTestObject -> Start();

    CActiveScheduler::Start();

    activeTestObject -> Stop();

    CActiveScheduler::Start();

    iLog->Log( _L("UsbServiceState = %d, expected %d"), 

                           iUsbServiceState, iUsbClassControllerPlugIn -> State());

    STIF_ASSERT_EQUALS( iUsbServiceState, iUsbClassControllerPlugIn -> State() );    

    DeleteTestObject();

    activeTestObject -> Cancel();

    // Case was executed

    iLog->Log( _L("Test Case Passed"));

    aTestResult = ETestCasePassed;

    return KErrNone;

    }

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

// CUsbObexClassControllerTest::InterfaceInfoTestL

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

//

TInt CUsbObexClassControllerTest::InterfaceInfoTestL( TUsbObexClassControllerTestResult& aTestResult )

    {

    TUsbDescriptor aDescriptorInfo;

    RImplInfoPtrArray implInfoArray;

    CleanupClosePushL(implInfoArray);

    TEComResolverParams resolverParams;

    TInt numberOfInterfaces;

    InitializeTestObjectL();

    CUSBObexApiTestActiveObject* activeTestObject = 

            CUSBObexApiTestActiveObject::NewL( iLog, iUsbClassControllerPlugIn );

    activeTestObject -> Start();

    CActiveScheduler::Start();

    iUsbClassControllerPlugIn -> GetDescriptorInfo( aDescriptorInfo ); 

    resolverParams.SetDataType( KSrcsTransportUSB );

    resolverParams.SetWildcardMatch( EFalse );

    REComSession::ListImplementationsL( KCSrcsInterfaceUid, resolverParams, implInfoArray );

    numberOfInterfaces = implInfoArray.Count() * KObexNumInterfaces;

    iLog->Log( _L("Number of interfaces = %d, expected %d"), 

                        numberOfInterfaces, aDescriptorInfo.iNumInterfaces);

    STIF_ASSERT_EQUALS( numberOfInterfaces, aDescriptorInfo.iNumInterfaces );

    DeleteTestObject();

    activeTestObject -> Cancel();

    CleanupStack::PopAndDestroy(&implInfoArray);    

    // Case was executed

    iLog->Log( _L("Test Case Passed"));

    aTestResult = ETestCasePassed;

    return KErrNone;

    }

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

// CUsbObexClassControllerTest::InterfaceLengthInfoTestL

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

//

TInt CUsbObexClassControllerTest::InterfaceLengthInfoTestL( TUsbObexClassControllerTestResult& aTestResult )

    {

    TUsbDescriptor aDescriptorInfo;

    RImplInfoPtrArray implInfoArray;

    CleanupClosePushL(implInfoArray);

    TEComResolverParams resolverParams;

    TInt interfaceLength = 0;

    InitializeTestObjectL();

    CUSBObexApiTestActiveObject* activeTestObject = 

            CUSBObexApiTestActiveObject::NewL( iLog, iUsbClassControllerPlugIn );

    activeTestObject -> Start();

    CActiveScheduler::Start();

    iUsbClassControllerPlugIn -> GetDescriptorInfo( aDescriptorInfo );

    resolverParams.SetDataType( KSrcsTransportUSB );

    resolverParams.SetWildcardMatch( EFalse );

    REComSession::ListImplementationsL( KCSrcsInterfaceUid, resolverParams, implInfoArray );

    iLog->Log( _L("Interface Length = %d, expected %d"), 

                                    interfaceLength, aDescriptorInfo.iLength);

    STIF_ASSERT_EQUALS( interfaceLength, aDescriptorInfo.iLength );

    DeleteTestObject();

    activeTestObject -> Cancel();

    CleanupStack::PopAndDestroy(&implInfoArray);    

    // Case was executed

    iLog->Log( _L("Test Case Passed"));

    aTestResult = ETestCasePassed;

    return KErrNone;

    }

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

// CUsbObexClassControllerTest::NumberOfInterfacesInfoTestL

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

//

TInt CUsbObexClassControllerTest::NumberOfInterfacesInfoTestL( TUsbObexClassControllerTestResult& aTestResult )

    {

    TUsbDescriptor aDescriptorInfo;

    RImplInfoPtrArray implInfoArray;

    CleanupClosePushL(implInfoArray);

    TEComResolverParams resolverParams;

    TInt interfaceLength = 0;

    InitializeTestObjectL();

    CUSBObexApiTestActiveObject* activeTestObject =

									CUSBObexApiTestActiveObject::NewL( iLog, iUsbClassControllerPlugIn );

    activeTestObject -> Start();

    CActiveScheduler::Start();

    iUsbClassControllerPlugIn -> GetDescriptorInfo( aDescriptorInfo );

    resolverParams.SetDataType( KSrcsTransportUSB );

    resolverParams.SetWildcardMatch( EFalse );

    REComSession::ListImplementationsL( KCSrcsInterfaceUid, resolverParams, implInfoArray );

    iLog->Log( _L("Number of Interfaces this class controller is responsible for  = %d, expected %d"), 

                                    interfaceLength, aDescriptorInfo.iNumInterfaces);

    STIF_ASSERT_EQUALS( interfaceLength, aDescriptorInfo.iLength );

    DeleteTestObject();