// Copyright (c) 2007-2010 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 "b2bwatchers.h"

#include "testcase1233.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "testcase1233Traces.h"

#endif

#include <e32debug.h> 

#define LOG_INTO_STEP(a) test.Printf(_L("\nInto Step [%S]\n\n"), &a);

/* **************************************************************************************

 * 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-1233");

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

CTestCase1233* CTestCase1233::NewL(TBool aHost)

	{

	if(gVerboseOutput)

	    {

	    OstTraceFunctionEntry0(CTESTCASE1233_NEWL);

	    }

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CTestCase1233::CTestCase1233(TBool aHost)

	: CTestCaseB2BRoot(KTestCaseId, aHost, iStatus) 

	{

	if(gVerboseOutput)

	    {

	    OstTraceFunctionEntry0(CTESTCASE1233_CTESTCASE1233);

	    }

	} 

/**

 ConstructL

*/

void CTestCase1233::ConstructL()

	{

	if(gVerboseOutput)

	    {

	    OstTraceFunctionEntry0(CTESTCASE1233_CONSTRUCTL);

	    }

	iTestVID = 0x0E22;		// Symbian

	iTestPID = 0xF000 + 1233; // Test 1233

	BaseConstructL();

	}

CTestCase1233::~CTestCase1233()

	{

	if(gVerboseOutput)

	    {

	    OstTraceFunctionEntry0(CTESTCASE1233_DCTESTCASE1233);

	    }

	iCollector.DestroyObservers();

	Cancel();

	}

void CTestCase1233::ExecuteTestCaseL()

	{

	if(gVerboseOutput)

	    {

	    OstTraceFunctionEntry0(CTESTCASE1233_EXECUTETESTCASEL);

	    }

	iCaseStep = EPreconditions;

	CActiveScheduler::Add(this);

	SelfComplete();

	}

void CTestCase1233::DoCancel()

	{

	if(gVerboseOutput)

	    {

	    OstTraceFunctionEntry0(CTESTCASE1233_DOCANCEL);

	    }

	// cancel our timer

	iTimer.Cancel();

	}

void CTestCase1233::RunStepL()

	{

	if(gVerboseOutput)

	    {

	    OstTraceFunctionEntry0(CTESTCASE1233_RUNSTEPL);

	    }

	// Obtain the completion code for this CActive obj.

	TInt completionCode(iStatus.Int()); 

	TBuf<MAX_DSTRLEN> aDescription;

	switch(iCaseStep)

		{

		/*==================================================*/

		/* Fixed 'pre' steps								*/

		/*==================================================*/

		case EPreconditions:

			{

			LOG_INTO_STEP(_L("EPreconditions"))

			iCaseStep = ELoadLdd;

			StepB2BPreconditions();	

			break;

			}

		case ELoadLdd:

			{

			LOG_INTO_STEP(_L("ELoadLdd"))

			// Note we use here the hex equivalent of #1233 for the PID

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

				{

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

				}

			//  load OTG ldd and init.		

			if (!StepLoadLDD())

				{

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

				}

			if(otgActivateFdfActor()!=KErrNone)

				{

				return TestFailed(KErrAbort, _L("Couldn't load FDF Actor"));

				}

			// test that the right cable is in

			CheckRoleConnections();

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

				}

			// Allow enough time for 8 enumerations, say a second each, plus two of the

			// tests require 15 seconds of SOF traffic

			const TInt KTestCase1233Timeout = 45000;

			iCollector.AddStepTimeout(KTestCase1233Timeout);

			iCollector.ClearAllEvents();

			iCaseStep = ERaiseVBus;

			SelfComplete();

			break;

			}

		/*==================================================*/

		/* Steps for this test case only					*/

		/*==================================================*/

		case ELoopToNextPID:

			{

			LOG_INTO_STEP(_L("ELoopToNextPID"));

			if (KTestCaseWatchdogTO == iStatus.Int())

				{

				iCollector.DestroyObservers();

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

				}

			if ( iTestVID == 0x0E22 )

				{

				iTestVID = 0x1A0A;	// OPT and test devices

				iTestPID = 0x0100; 	// One *before* the first HS test ID

				}

			iTestPID++;

			if ( iTestPID > 0x0108 )

				{

				test.Printf(_L("All VID/PID pairs done\n"));

				OstTrace0(TRACE_NORMAL, CTESTCASE1233_RUNSTEPL_DUP01, "All VID/PID pairs done\n");

				iCaseStep = EUnloadLdd;

				}

			else

				{

				if(gTestRoleMaster)

					{

					// B

					test.Printf(_L("Setting VID/PID of 0x%04x/0x%04x\n"),iTestVID,iTestPID);

					OstTraceExt2(TRACE_NORMAL, CTESTCASE1233_RUNSTEPL_DUP02, "Setting VID/PID of 0x%04x/0x%04x\n",(TUint32)iTestVID,(TUint32)iTestPID);

					if (!StepChangeVidPid(iTestVID,iTestPID))

						{

						return TestFailed(KErrAbort, _L("VID/PID Change Failure"));

						}

					}

				else

					{

					// A

					test.Printf(_L("Expecting VID/PID of 0x%04x/0x%04x\n"),iTestVID,iTestPID);

					OstTraceExt2(TRACE_NORMAL, CTESTCASE1233_RUNSTEPL_DUP03, "Expecting VID/PID of 0x%04x/0x%04x\n",(TUint32)iTestVID,(TUint32)iTestPID);

					}

				iCollector.ClearAllEvents();

				iCaseStep = ERaiseVBus;

				}

			SelfComplete();

			break;			

			}

		case ERaiseVBus:

			{

			LOG_INTO_STEP(_L("ERaiseVBus"));

			if (KTestCaseWatchdogTO == iStatus.Int())

				{

				iCollector.DestroyObservers();

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

				}			

			if (gTestRoleMaster)

				{

				// B device

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

				iCollector.AddRequiredNotification(EWatcherState, RUsbOtgDriver::EStateBPeripheral);

				iCollector.AddRequiredNotification(EWatcherPeripheralState, EUsbcDeviceStateDefault);

				iCollector.AddRequiredNotification(EWatcherPeripheralState, EUsbcDeviceStateAddress);

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

				iCollector.AddRequiredNotification(EWatcherPeripheralState, EUsbcDeviceStateConfigured);

				}

			else

				{ 

				// A device

				test.Printf(_L("Raising VBUS for VID/PID = 0x%04x/0x%04x\n"),iTestVID,iTestPID);

				OstTraceExt2(TRACE_NORMAL, CTESTCASE1233_RUNSTEPL_DUP04, "Raising VBUS for VID/PID = 0x%04x/0x%04x\n",(TUint32)iTestVID,(TUint32)iTestPID);

				if ( otgBusRequest() != KErrNone )

					{

					return TestFailed(KErrAbort, _L("Raise Vbus - RUsbOtgDriver::BusRequest() FAILED!"));

					}

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

				iCollector.AddRequiredNotification(EWatcherAConnectionIdle, RUsbOtgDriver::EConnectionBusy);

				iCollector.AddRequiredNotification(EWatcherState, RUsbOtgDriver::EStateAHost);

				}

			iCaseStep = EVBusRaised;

			SetActive();

			break;

			}

		case EVBusRaised:

			{

			LOG_INTO_STEP(_L("EVBusRaised"));

			if (KTestCaseWatchdogTO == iStatus.Int())

				{

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

				}

			if ( otgVbusPresent() )

				{

				test.Printf(_L("...VBUS is UP\n"));

				OstTrace0(TRACE_NORMAL, CTESTCASE1233_RUNSTEPL_DUP05, "...VBUS is UP\n");

				iCaseStep = EDropVBus;

				}

			else

				{

				test.Printf(_L("...VBUS is DOWN\n"));

				OstTrace0(TRACE_NORMAL, CTESTCASE1233_RUNSTEPL_DUP06, "...VBUS is DOWN\n");

				return TestFailed(KErrAbort, _L("Vbus did not rise - FAILED!"));

				}

			if (gTestRoleMaster)

				{

				// B device

				SelfComplete();

				}

			else

				{ 

				// A device

				// The default device (0x0E22/0xB4D1) is passed to the FDF, which will (eventually)

				// suspend and enter connection idle state.

				// The HS test devices (0x1A0A) will not be presented to FDF, so there will be no

				// trailing connection idle to find.

				if ( iTestVID == 0x0E22 )

					{

					iCollector.AddRequiredNotification(EWatcherAConnectionIdle, RUsbOtgDriver::EConnectionIdle);

					SetActive();

					}

				else

					{

					SelfComplete();

					}

				}

			break;

			}

		case EDropVBus:

			{

			LOG_INTO_STEP(_L("EDropVBus"));

			if (KTestCaseWatchdogTO == iStatus.Int())

				{

				iCollector.DestroyObservers();

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

				}			

			if ( gTestRoleMaster)

				{

				// B device

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

				}

			else

				{

				// A device

				otgBusDrop();

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

				}

			iCaseStep = EVBusDropped;

			SetActive();

			break;

			}

		case EVBusDropped:

			{

			LOG_INTO_STEP(_L("EVBusDropped"));

			if (KTestCaseWatchdogTO == iStatus.Int())

				{

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

				}

			if ( otgVbusPresent() )

				{

				test.Printf(_L("...VBUS is UP\n"));

				OstTrace0(TRACE_NORMAL, CTESTCASE1233_RUNSTEPL_DUP07, "...VBUS is UP\n");

				return TestFailed(KErrAbort, _L("Vbus did not rise - FAILED!"));

				}

			else

				{

				test.Printf(_L("...VBUS is DOWN\n"));

				OstTrace0(TRACE_NORMAL, CTESTCASE1233_RUNSTEPL_DUP08, "...VBUS is DOWN\n");

				iCaseStep = ELoopToNextPID;

				}

			SelfComplete();

			break;

			}

		/*==================================================*/

		/* Fixed 'post' steps								*/

		/*==================================================*/

		case EUnloadLdd:

			{

			LOG_INTO_STEP(_L("EUnloadLdd"))

			otgDeactivateFdfActor();

			iCollector.DestroyObservers();

			if (EFalse == StepUnloadLDD()){

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

			}

			if (!StepUnloadClient()){

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

			}

			iCaseStep = ELastStep;

			SelfComplete();

			break;

			}

		case ELastStep:

			{

			LOG_INTO_STEP(_L("ELastStep"))

			TestPassed();

			RequestCharacter();	

			break;

			}

		default:

			{

			LOG_INTO_STEP(_L("DEFAULT! (unknown test step)"));

			Cancel();

			RequestCharacter();	

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

			}

		}

	}