/*

* Copyright (c) 2002-2009 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:

* This test program provides menu-driven functional tests for the USB Manager which exercise

* every exported API it provides. Note that, to use this program with Hurricane USB, the macro

* HURRICANE should be defined in the t_usbman.mmp file.

* WARNING: Some of these tests rely on the 'dummy class controller' build of 

* USBMAN. This is produced with t_usbman_dummycc.mmp, and it includes three 

* instances of the dummy class controller (mainly used for GT171 automated 

* tests). To get this to operate correctly a suitable ini file must be copied 

* to c:\dummy.ini, for instance usbman\data\test.ini, which provides delayed 

* asynchronous Start and Stop behaviour for each of the dummy CC instances.

*

*/

#include <e32base.h>

#include <e32math.h>

#include <e32cons.h>

#include <badesca.h>

#include <c32comm.h>

#include <usbman.h>

#include <e32property.h> //Publish & Subscribe header, required for setting serial number

#include "usb.h"

LOCAL_D CConsoleBase* console;

RTimer TheTimer;

RCommServ TheCommServ;

RUsb TheUsb;

RUsb TheSecondUsbSession;

TBool ThePrimaryClient;

_LIT(KUsbLddName, "EUSBC");

// These are used in the startup stress test.

TInt64 TheRandomSeed = 0;

const TInt KMaxCancelTime = 2000000;

const TInt KMaxStopTime = 10000000;

#define _printf console->Printf

#define _getch console->Getch

#define LEAVE(_x) VerboseLeaveL(_x, __LINE__, TPtrC8((const TUint8*)__FILE__), _L8(#_x))

#define LEAVEIFERROR(_x) VerboseLeaveIfErrorL(_x, __LINE__, TPtrC8((const TUint8*)__FILE__), _L8(#_x))

#define CHECK(_x) if (! (_x)) VerboseLeaveL(KErrGeneral, __LINE__, TPtrC8((const TUint8*)__FILE__), _L8(#_x))

////////////////////////////////////////////////////////////////////////////////

// Helper functions below this point

////////////////////////////////////////////////////////////////////////////////

void VerboseLeaveL(TInt aError, TInt aLineNum, const TDesC8& aFileName, const TDesC8& aCode)

	{

	TInt filenameOffset = aFileName.LocateReverse('\\') + 1;

	if (filenameOffset < 0) filenameOffset = 1;

	TPtrC8 shortFileName = aFileName.Mid(filenameOffset);

	TBuf<64> fName, code;

	fName.Copy(shortFileName.Left(64));

	code.Copy(aCode.Left(64));

	_printf(_L("ERROR (%d) on line %d of file %S\n"), aError, aLineNum, &fName);

	_printf(_L("Code: %S\n\n"), &code);

	_printf(_L("[ press any key ]"));

	_getch();

	User::Leave(aError);

	}

void VerboseLeaveIfErrorL(TInt aError, TInt aLineNum, const TDesC8& aFileName, const TDesC8& aCode)

	{

	if (aError) 

		VerboseLeaveL(aError, aLineNum, aFileName, aCode);

	}

void ReadString(TDes& aDes)

/**

 * Reads user input into the start of the descriptor aDes.

 */

	{

	TChar inputKey;

	TInt count = 0;

	aDes.Zero();

	for (;;)

		{

		inputKey = (TInt) _getch();

		if ((TInt)inputKey == EKeyEnter)

			break;

		if(inputKey == EKeyBackspace)

			{

			if (count > 0)

				{

 				_printf(_L("%C"), (TUint) inputKey);

				aDes.Delete(--count,1);

				}

			}

		else if(inputKey.IsPrint())

			{

			_printf(_L("%C"), (TUint) inputKey);

			aDes.Append(inputKey);

			count++;

			}

		}

	}

void PrintUsbServiceState(TUsbServiceState aServiceState)

	{

	switch (aServiceState)

		{

	case EUsbServiceIdle: _printf(_L("USB service is idle.\n")); break;

	case EUsbServiceStarting: _printf(_L("USB service is starting.\n")); break;

	case EUsbServiceStarted: _printf(_L("USB service is started.\n")); break;

	case EUsbServiceStopping: _printf(_L("USB service is stopping.\n")); break;

#ifndef HURRICANE

	case EUsbServiceFatalError: _printf(_L("USB service has a fatal error.\n")); break;

#endif // HURRICANE

	default:

		_printf(_L("ERROR: unknown service state!\n"));

		break;

		}

	}

void PrintUsbDeviceState(TUsbDeviceState aDeviceState)

	{

	switch (aDeviceState)

		{

	case EUsbDeviceStateUndefined:

		_printf(_L("USB device state is undefined.\n"));

		break;

	case EUsbDeviceStateDefault:

		_printf(_L("USB device state is default.\n"));

		break;

	case EUsbDeviceStateAttached:

		_printf(_L("USB device state is attached.\n"));

		break;

	case EUsbDeviceStatePowered:

		_printf(_L("USB device state is powered.\n"));

		break;

	case EUsbDeviceStateConfigured:

		_printf(_L("USB device state is configured.\n"));

		break;

	case EUsbDeviceStateAddress:

		_printf(_L("USB device state is address.\n"));

		break;

	case EUsbDeviceStateSuspended:

		_printf(_L("USB device state is suspended.\n"));

		break;

	default:

		_printf(_L("ERROR: unknown device state!\n"));

		break;

		}

	}

////////////////////////////////////////////////////////////////////////////////

// Test cases below this point

////////////////////////////////////////////////////////////////////////////////

void OpenUsbL()

	{

	LEAVEIFERROR(TheUsb.Connect());

	}

void CloseUsbL()

	{

	TheUsb.Close();

	}

// USB test cases 3.1.1, 3.1.2 and 3.1.4, startup from primary and non-primary sessions.

void StartUsbL()

	{

	TRequestStatus status;

	TheUsb.Start(status);

	User::WaitForRequest(status);

	LEAVEIFERROR(status.Int());

	_printf(_L("Started USB.\n"));

	}

// USB test cases 3.2 and (part of) 3.4, startup cancellation.

void CancelStartingUsbL(TBool aCancelByStopping)

	{

	TRequestStatus cancelStatus;

	TRequestStatus timerStatus;

	TInt cancelTime = 0;

	while (cancelTime < (100 * 1000000))

		{

		_printf(_L("Cancelling after %d microseconds\n"), cancelTime);

		TheTimer.After(timerStatus, cancelTime);

		TheUsb.Start(cancelStatus);

		User::WaitForRequest(cancelStatus, timerStatus);

		// If the request has finished before the timer completed,

		// cancel the timer and check the request status for errors.

		if (timerStatus == KRequestPending)

			{

			TheTimer.Cancel();

			User::WaitForRequest(timerStatus);

			LEAVEIFERROR(cancelStatus.Int());

			break;

			}

		// The timer should never complete with an error.

		LEAVEIFERROR(timerStatus.Int());

		// Cancel the start. The option of cancelling by stopping is only available

		// from version 7.0s, because in Hurricane a stop while starting is

		// actually implemented as a cancel.

#ifndef HURRICANE

		if (aCancelByStopping)

			{

			TRequestStatus stopStatus;

			TheUsb.Stop(stopStatus);

			User::WaitForRequest(stopStatus);

			LEAVEIFERROR(stopStatus.Int());

			}

		else

#endif // HURRICANE

			{

			TheUsb.StartCancel();

			}

		User::WaitForRequest(cancelStatus);

		// If the start actually completed, just return.

		if (cancelStatus == KErrNone)

			break;

#ifndef HURRICANE

		// If we're cancelling by stopping, then getting this error code is

		// expected.

		if (cancelStatus == KErrUsbServiceStopped)

			{

			cancelTime += 50000;

			continue;

			}

#endif // HURRICANE

		if (cancelStatus != KErrCancel)

			LEAVE(cancelStatus.Int());

		cancelTime += 50000;

		}

	TUsbServiceState serviceState;

	LEAVEIFERROR(TheUsb.GetCurrentState(serviceState));

	PrintUsbServiceState(serviceState);

	}

// Part of USB test case 3.4, stopping class controllers.

void StopUsbSynchronousL()

	{

	TheUsb.Stop();

	_printf(_L("Stopped USB.\n"));

	}

#ifndef HURRICANE

// Part of USB test case 3.4, stopping class controllers.

void StopUsbAsynchronousL()

	{

	TRequestStatus status;

	TheUsb.Stop(status);

	User::WaitForRequest(status);

	LEAVEIFERROR(status.Int());

	_printf(_L("Stopped USB.\n"));

	}

void CancelStoppingUsbL(TBool aCancelByStarting)

	{

	TRequestStatus cancelStatus;

	TRequestStatus timerStatus;

	TInt cancelTime = 0;

	while (cancelTime < (100 * 1000000))

		{

		_printf(_L("Cancelling after %d microseconds\n"), cancelTime);

		TheTimer.After(timerStatus, cancelTime);

		TheUsb.Stop(cancelStatus);

		User::WaitForRequest(cancelStatus, timerStatus);

		// If the request has finished before the timer completed,

		// cancel the timer and check the request status for errors.

		if (timerStatus == KRequestPending)

			{

			TheTimer.Cancel();

			User::WaitForRequest(timerStatus);

			LEAVEIFERROR(cancelStatus.Int());

			break;

			}

		// The timer should never complete with an error.

		LEAVEIFERROR(timerStatus.Int());

#ifndef HURRICANE 

		if (aCancelByStarting) 

			{ 

			TRequestStatus startStatus; 

			TheUsb.Start(startStatus); 

			User::WaitForRequest(startStatus); 

			LEAVEIFERROR(startStatus.Int()); 

			} 

		else 

#endif // HURRICANE 

			{ 

			TheUsb.StopCancel(); 

			}

		User::WaitForRequest(cancelStatus);

		// If the stop actually completed, just return.

		if (cancelStatus == KErrNone)

			break;

#ifndef HURRICANE 

		// If we're cancelling by starting, then getting this 

		// error code is expected. 

	    if (cancelStatus == KErrUsbServiceStarted) 

			{ 

			cancelTime += 50000; 

			continue; 

			} 

#endif // HURRICANE 

		if (cancelStatus != KErrCancel)

			LEAVE(cancelStatus.Int());

		cancelTime += 50000;

		}

	TUsbServiceState serviceState;

	LEAVEIFERROR(TheUsb.GetCurrentState(serviceState));

	PrintUsbServiceState(serviceState);

	}

#endif // HURRICANE

void RestartUsbL()

	{

	TheUsb.Stop();

	TRequestStatus status;

	TheUsb.Start(status);

	User::WaitForRequest(status);

	LEAVEIFERROR(status.Int());

	_printf(_L("\nRestarted USB.\n"));

	}

// USB test case 3.6, stress testing of startup and shutdown.

void StartupStressTestL()

	{

	TRequestStatus cancelStatus;

	TRequestStatus timerStatus;

	TInt cancelTime = Math::Rand(TheRandomSeed) % KMaxCancelTime;

	TInt stopTime;

	for (TInt i = 0; i < 100; i++)

		{

		_printf(_L("Cancelling after %d microseconds\n"), cancelTime);

		TheTimer.After(timerStatus, cancelTime);

		TheUsb.Start(cancelStatus);

		User::WaitForRequest(cancelStatus, timerStatus);

		// If the request has finished before the timer completed,

		// cancel the timer and check the request status for errors.

		if (timerStatus == KRequestPending)

			{

			TheTimer.Cancel();

			LEAVEIFERROR(cancelStatus.Int());

			}

		else

			{

			// The timer should never complete with an error.

			LEAVEIFERROR(timerStatus.Int());

			// Cancel the start.

			TheUsb.StartCancel();

			User::WaitForRequest(cancelStatus);

			}

		// If the start actually completed, then try stopping.

		if (cancelStatus == KErrNone)

			{

			stopTime = Math::Rand(TheRandomSeed) % KMaxStopTime;

			_printf(_L("Stopping after %d microseconds\n"), stopTime);

			User::After(stopTime);

			TheUsb.Stop();

			}

		else if (cancelStatus != KErrCancel)

			{

			LEAVE(cancelStatus.Int());

			}

		cancelTime = Math::Rand(TheRandomSeed) % KMaxCancelTime;

		}

	_printf(_L("USB is now stopped\n"));

	}

// USB test case 3.3, monitoring the state of the USB.

void MonitorUsbDeviceStateL()

	{

	TRequestStatus consoleStatus;

	TRequestStatus notifyStatus;

	TUsbServiceState serviceState;

	TUsbDeviceState deviceState;

	LEAVEIFERROR(TheUsb.GetCurrentState(serviceState));

	_printf(_L("\n"));

	PrintUsbServiceState(serviceState);

#ifndef HURRICANE

	LEAVEIFERROR(TheUsb.GetDeviceState(deviceState));

	PrintUsbDeviceState(deviceState);

#endif // HURRICANE

	_printf(_L("\nMonitoring the state of USB - press any key to stop\n\n"));

	console->Read(consoleStatus);

	while (consoleStatus == KRequestPending)

		{

		TheUsb.StateNotification(0xFFFFFFFF, deviceState, notifyStatus);

		User::WaitForRequest(notifyStatus, consoleStatus);

		if (consoleStatus == KRequestPending)

			{

			if (notifyStatus != KErrNone)

				{

				// need to cancel the read to avoid a CBase-77 panic!

				console->ReadCancel();

				LEAVE(notifyStatus.Int());

				}

			}

		else

			{

			// The user's pressed a key.

			TheUsb.StateNotificationCancel();

			User::WaitForRequest(notifyStatus);

			break;

			}

		PrintUsbDeviceState(deviceState);

		}

	_printf(_L("\nTest complete\n"));

	}

// Concurrency test case (3.9.1 in test spec). One client starts USB and then another

// one stops it.

void StartAThenStopBL()

	{

	LEAVEIFERROR(TheSecondUsbSession.Connect());

	TRequestStatus status;

	TUsbServiceState serviceState;

	// Start on client 1.

	TheUsb.Start(status);

	User::WaitForRequest(status);

	LEAVEIFERROR(status.Int());

	// Get status on both sessions.

	LEAVEIFERROR(TheUsb.GetCurrentState(serviceState));

	_printf(_L("\nSession 1: "));

	PrintUsbServiceState(serviceState);

	LEAVEIFERROR(TheSecondUsbSession.GetCurrentState(serviceState));

	_printf(_L("Session 2: "));

	PrintUsbServiceState(serviceState);

	// Stop on client 2.

	TheSecondUsbSession.Stop();

	// Get status on both sessions.

	LEAVEIFERROR(TheUsb.GetCurrentState(serviceState));

	_printf(_L("Session 1: "));

	PrintUsbServiceState(serviceState);

	LEAVEIFERROR(TheSecondUsbSession.GetCurrentState(serviceState));

	_printf(_L("Session 2: "));

	PrintUsbServiceState(serviceState);

	TheSecondUsbSession.Close();

	}

// Concurrency test case (3.9.2 in test spec). One client stops USB while it's being

// started by another one.

void StopBWhileAStartingL()

	{

	LEAVEIFERROR(TheSecondUsbSession.Connect());

	TRequestStatus status;

	TUsbServiceState serviceState;

	// Start on client 1.

	TheUsb.Start(status);

	// Stop on client 2.

	TheSecondUsbSession.Stop();

	// Wait for start request to complete.

	User::WaitForRequest(status);

	if (status.Int() != KErrUsbServiceStopped)