// 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")));

 		}

 	}