// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// @internalComponent

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <u32std.h> 	// unicode builds

#include <e32base.h>

#include <e32base_private.h>

#include <e32Test.h>	// RTest headder

#include "testcaseroot.h"

#include "testcasewd.h"

#include "testcase0469.h"

#define _REPEATS (oOpenIterations*3)

// the name below is used to add a pointer to our construction method to a pointer MAP in 

// the class factory

_LIT(KTestCaseId,"PBASE-USB_OTGDI-0469");

const TTestCaseFactoryReceipt<CTestCase0469> CTestCase0469::iFactoryReceipt(KTestCaseId);	

CTestCase0469* CTestCase0469::NewL(TBool aHost)

	{

	LOG_FUNC

	CTestCase0469* self = new (ELeave) CTestCase0469(aHost);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTestCase0469::CTestCase0469(TBool aHost)

	: CTestCaseB2BRoot(KTestCaseId, aHost, iStatus) 

	{

	LOG_FUNC

	} 

/**

 ConstructL

*/

void CTestCase0469::ConstructL()

	{

	LOG_FUNC

    iDualRoleCase = EFalse; // Not back to back

	BaseConstructL();

	}

CTestCase0469::~CTestCase0469()

	{

	LOG_FUNC

    iCollector.DestroyObservers();

	Cancel();

	}

void CTestCase0469::ExecuteTestCaseL()

	{

	LOG_FUNC

	iCaseStep = EPreconditions;

	iRepeats = 3;

	CActiveScheduler::Add(this);

	SelfComplete();

	}

void CTestCase0469::DoCancel()

	{

	LOG_FUNC

	// cancel our timer

	iTimer.Cancel();

	}

// handle event completion	

void CTestCase0469::RunStepL()

	{

	LOG_FUNC

	// Obtain the completion code for this CActive obj.

	TInt completionCode(iStatus.Int()); 

	TBuf<MAX_DSTRLEN> aDescription;

    //	15 seconds, should be plenty of time for 3 cycles of plug pulling

    const TInt KTestCase0469Timeout = 15000;

	switch(iCaseStep)

		{

    case EPreconditions:

        LOG_STEPNAME(_L("EPreconditions"))

        iCaseStep = ELoadLdd;

        // prompt to insert connectors

        test.Printf(KInsertBCablePrompt);

        test.Printf(KRemoveAFromPC);

        test.Printf(KPressAnyKeyToContinue);

        RequestCharacter();			

        break;

    case ELoadLdd:

        LOG_STEPNAME(_L("ELoadLdd"))

        if (!StepLoadClient(0xF678/*use default settings for SRP/HNP support*/))

            {

            return TestFailed(KErrAbort, _L("Client Load Failure"));

            }

        if (!StepLoadLDD())

            {

            return TestFailed(KErrAbort, _L("OTG Load Failure"));

            }

        // subscribe to OTG states,events and messages now that it has loaded OK

        TRAPD(result, iCollector.CreateObserversL(*this));

        if (KErrNone != result)

            {

            return(TestFailed(KErrNoMemory, _L("Unable to create observers")));

            }

        iCollector.ClearAllEvents();

        iCaseStep = ELoopControl;

		iCollector.AddStepTimeout(KTestCase0469Timeout);

        SelfComplete();

        break;

    case ELoopControl:

        LOG_STEPNAME(_L("ELoopControl"))

        // Check for timeout

        if (KTestCaseWatchdogTO == iStatus.Int())

            {

            iCollector.DestroyObservers();

            return TestFailed(KErrAbort, _L("Timeout"));

            }

        if (iRepeats--)

            {

            RDebug::Printf("ELoopControl around again %d", iRepeats);

            iCaseStep = ETestVbusRise;

            }

        else

            {

            RDebug::Printf("ELoopControl we're done");

            iCaseStep = EUnloadLdd;

            }

        SelfComplete();

        break;

    case ETestVbusRise:

        LOG_STEPNAME(_L("ETestVbusRise"))

        // Check for timeout

        if (KTestCaseWatchdogTO == iStatus.Int())

            {

            iCollector.DestroyObservers();

            return TestFailed(KErrAbort, _L("Timeout"));

            }

        iCollector.AddRequiredNotification(EWatcherEvent, RUsbOtgDriver::EEventVbusRaised);

        iCaseStep = ETestVbusFall;

        test.Printf(KInsertAIntoPC);

        SetActive();

        break;

    case ETestVbusFall:

        LOG_STEPNAME(_L("ETestVbusFall"))

        // Check for timeout

        if (KTestCaseWatchdogTO == iStatus.Int())

            {

            iCollector.DestroyObservers();

            return TestFailed(KErrAbort, _L("Timeout"));

            }

        iCollector.AddRequiredNotification(EWatcherEvent, RUsbOtgDriver::EEventVbusDropped);

        iCaseStep = ELoopControl;

        test.Printf(KRemoveAFromPC);

        SetActive();

        break;

    case EUnloadLdd:

        LOG_STEPNAME(_L("EUnloadLdd"))

        iCollector.DestroyObservers();

        RDebug::Printf("Destroyed observers");

        if (EFalse == StepUnloadLDD())

            return TestFailed(KErrAbort,_L("unload Ldd failure"));	

        RDebug::Printf("unloaded ldd");

        if (!StepUnloadClient())

            return TestFailed(KErrAbort,_L("Client Unload Failure"));	

        RDebug::Printf("unloaded client");

        iCaseStep = ELastStep;

        SelfComplete();

        break;

    case ELastStep:

        LOG_STEPNAME(_L("ELastStep"))

        TestPassed();

        break;

    default:

        test.Printf(_L("<Error> unknown test step"));

        Cancel();

        return (TestFailed(KErrCorrupt, _L("<Error> unknown test step")));

		}

	}