// Copyright (c) 1997-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:

// e32test\pccd\t_medch.cpp

// Continuously generate media changes followesd by a remount of the peripheral bus controller.

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32svr.h>

#include <hal.h>

#include "d_medch.h"

//#define __SOAK_TEST__				// Define to run until a key is pressed (Automatic tests only)

//#define __MANUAL_TEST__			// Define to allow manual control of the door/media

//#define __DEVICE_HAS_NO_DOOR__	// Define for devices that have no door (Manual tests only)

#if defined(__MANUAL_TEST__) && defined(__WINS__)

#define __DEVICE_HAS_NO_DOOR__

#endif

#if !defined(__MANUAL_TEST__) && defined(__DEVICE_HAS_NO_DOOR__)

#undef __DEVICE_HAS_NO_DOOR__

#endif

#if defined(__MANUAL_TEST__) && defined(__SOAK_TEST__)

#undef __SOAK_TEST__

#endif

#ifndef __SOAK_TEST__

#ifdef __WINS__

const TInt KMaxTestTime	=  5000000;	// Run the test for 5 seconds on emulator

#else

const TInt KMaxTestTime	= 10000000;	// Run the test for 10 seconds on target

#endif

#endif

#define MMC_PDD_NAME _L("MEDMMC")

const TInt KPowerUpTimeOut = 5000000; // Give the card 5 seconds to power up

LOCAL_D	RTest test(_L("Media change test"));

LOCAL_D	TBusLocalDrive TheDrive;

LOCAL_D	RMedCh TheMediaChange;

LOCAL_D TRequestStatus TheMediaStatus;

LOCAL_D TBool TheChangedFlag;

LOCAL_C TBool SetupDrivesForPlatform(TInt& aDrive, TInt& aSocket)

/**

 * Finds a suitable drive for the media change test

 *

 * @param aDrive  The number of the local drive to test

 * @param aSocket The number of the socket to test

 * @return TBool ETrue if a suitable drive is found, EFalse otherwise.

 */

	{

	TDriveInfoV1Buf diBuf;

	UserHal::DriveInfo(diBuf);

	TDriveInfoV1 &di=diBuf();

	aDrive  = -1;

	aSocket = -1;

	for(aDrive=0; aDrive < di.iTotalSupportedDrives; aDrive++)

		{

		test.Printf(_L(" Drive %d - %S\r\n"), aDrive, &di.iDriveName[aDrive]);

		if(di.iDriveName[aDrive].MatchF(_L("MultiMediaCard0")) == KErrNone)

			break;

		}

	if(aDrive == di.iTotalSupportedDrives)

		{

		test.Printf(_L(" MMC Drive Not Found\r\n"));

		return EFalse;

		}

	for(aSocket=0; aSocket < di.iTotalSockets; aSocket++)

		{

		test.Printf(_L("Socket %d - %S\r\n"), aSocket, &di.iSocketName[aSocket]);

		if(di.iSocketName[aSocket].MatchF(_L("MultiMediaCard0")) == KErrNone)

			break;

		}

	if(aSocket == di.iTotalSockets)

		{

		test.Printf(_L(" MMC Socket Not Found\r\n"));

		return EFalse;

		}

	return ETrue;

	}

LOCAL_C void TestMediaAccess(TInt aExpectedError, TBool aExpectedChange)

/**

 * Tests that the drive is accessable (or not) by issuing a request 

 * to power up the media.  Also verifies that the attributes are correct.

 * 

 * @param aExpectedError The expected result of powering up the drive

 * @param aExpectedChange ETrue if the changed flag is expected to be set

 *

 * @return ETrue if successful, EFalse otherwise

 */

	{

	RTimer rto;

	TInt r = rto.CreateLocal();

	test(r == KErrNone);

	TRequestStatus rtoStat;

	rto.After(rtoStat, KPowerUpTimeOut);

	test(rtoStat == KRequestPending);

	if(aExpectedChange)

		{

		// TheChangedFlag is set when the door is opened if media was present.

		// The asynch notifier is signalled when media is removed OR inserted.

		User::WaitForRequest(TheMediaStatus, rtoStat);

		test(TheMediaStatus != KRequestPending);

		}

	// ...aChangedFlag's purpose is to notify us of media removal.

	test_Equal(aExpectedChange,TheChangedFlag);

	TheDrive.NotifyChange(&TheMediaStatus);

	TheChangedFlag = EFalse;

	// Attempt to power up the drive

	TLocalDriveCapsV2Buf info;

	do

		{

		r = TheDrive.Caps(info);

		}

	while(r != aExpectedError && rtoStat == KRequestPending);

	rto.Cancel();

	rto.Close();

	// ...was the error as expected?

	test(r == aExpectedError);

	// ...and are the caps still OK?

	if(r == KErrNone)

		test(info().iType == EMediaHardDisk);

	else if(r == KErrNotReady)

		test(info().iType == EMediaNotPresent);

	if(aExpectedChange == EFalse)

		test(TheMediaStatus == KRequestPending);

	}

LOCAL_C void NextTest(const TDesC& aTitle, TInt aCycles)

/**

 * Simply displays a string on the console and the current iteration.

 * 

 * @param aTitle  The text to be displayed

 * @param aCycles The current iteration

 */

	{

	test.Console()->SetPos(20, 25);

	test.Printf(_L("%S [%d cycles]"), &aTitle, aCycles);

#ifdef __MANUAL_TEST__

	test.Console()->SetPos(20, 27);

	test.Printf(_L("<press a key>"));

	test.Getch();

#endif

	}

GLDEF_C TInt E32Main()

/**

 * Test Entry Point for T_MEDCH.

 * 

 * This test uses the associated driver (D_MEDCH) to simulate media removal and 

 * door opening/closing.  The media is powered up in each state and verified that 

 * the correct error code and changed count is returned.

 */

    {

	TBuf<64> b;

	test.Title();

	/**

	 * Load the associated media driver (MEDMMC by default).  This is required to ensure 

	 * that the device can be powered up and the capabilities if the media accessed.

	 */

	test.Start(_L("Load Media Driver"));

	TInt r;

	r=User::LoadPhysicalDevice(MMC_PDD_NAME);

	if(r==KErrNotFound)

		{

		test.Printf(_L("Test not supported on this platform \n"));

		test.End();

		return(0);

		}

	test(r==KErrNone || r==KErrAlreadyExists);

	/**

	 * Connect to the required local drive.

	 * TheChangedFlag is used for detection of media removal.

	 */

	TInt drive;

	TInt socket;

	if(SetupDrivesForPlatform(drive, socket))

		{

		b.Format(_L("Connect to local drive %d"), drive);

		test.Next(b);

		TheDrive.Connect(drive, TheChangedFlag);

		/**

		 * Read the drive capabilities to ensure that this test may be run.

		 */

		test.Next(_L("Get drive capabilities"));

		TLocalDriveCapsV2Buf info;

		r = TheDrive.Caps(info);

		if(r == KErrNotReady || r == KErrNotSupported)

			{

			test.Next(_L("\r\nTest requires media to be present and the door closed - Disconnecting"));

			TheDrive.Disconnect();		

			test.End();

			return KErrNone;

			}	

		test(r == KErrNone);

		test(TheDrive.Caps(info) == KErrNone);

		test(info().iType == EMediaHardDisk);

		/**

		 * Load the media simulation test driver

		 */

		test.Next(_L("Load media change logical device"));

		r=User::LoadLogicalDevice(_L("D_MEDCH"));

		test(r == KErrNone || r == KErrAlreadyExists);

		test.Next(_L("Open device"));

		r=TheMediaChange.Open(socket, TheMediaChange.VersionRequired());

		if(r == KErrNotSupported)

			{

			test.Next(_L("\r\nTest not supported on this drive - Disconnecting"));

			r=User::FreeLogicalDevice(_L("MedCh"));

			test(r == KErrNone);

			TheDrive.Disconnect();

			test.End();

			return KErrNone;

			}	

		test(r == KErrNone);

		/**

		 * Verify that the system supports simulation of media change events

		 */

		test.Next(_L("Test support for media change simulation"));

		r = TheMediaChange.DoorNormal();

		test(r == KErrNone || r == KErrNotSupported);

		/**

		 * Now for the real testing...

		 */

		if(r == KErrNone)

			{

			/**

	    	 * Test0 - Simulate 2 consecutive door open interrupts

			 */

			test.Next(_L("Test that the pbus can handle 2 consecutive door open interrupts"));

			TheDrive.NotifyChange(&TheMediaStatus);

			r = TheMediaChange.DoubleDoorOpen();

			test(r == KErrNone || r == KErrNotSupported);

			TestMediaAccess(KErrNone, ETrue);

			TInt cycles=0;

#if defined(__SOAK_TEST__)

			TRequestStatus endStat;

			test.Console()->Read(endStat);

			while(endStat == KRequestPending)

#elif !defined(__MANUAL_TEST__)

			RTimer t;

			r=t.CreateLocal();

			test(r == KErrNone);

			TRequestStatus endStat;

			t.After(endStat, KMaxTestTime);

			test(endStat == KRequestPending);

			while(endStat == KRequestPending)

#endif

				{

				TheChangedFlag = EFalse;

				TheDrive.NotifyChange(&TheMediaStatus);

				/**

	    		 * Test1 - Simulate door open

				 *		 - Power up responds with KErrNotReady

				 */

				NextTest(_L("Open Door......"), cycles);

#ifndef __MANUAL_TEST__

				test(TheMediaChange.DoorOpen() == KErrNone);

#endif

				TestMediaAccess(KErrNotReady, ETrue);

				TheDrive.NotifyChange(&TheMediaStatus);

				/**

	    		 * Test2 - Simulate door closed (with media removed)

				 *		 - Power up responds with KErrNotReady

				 */

#ifndef __DEVICE_HAS_NO_DOOR__

	    		NextTest(_L("Remove Media..."), cycles);

#ifndef __MANUAL_TEST__

				test(TheMediaChange.DoorClose(EFalse) == KErrNone);		

#endif

				TestMediaAccess(KErrNotReady, EFalse);					

				/**

	    		 * Test3 - Simulate door open

				 *		 - Power up responds with KErrNotReady

				 */

				NextTest(_L("Open Door......"), cycles);

#ifndef __MANUAL_TEST__

				test(TheMediaChange.DoorOpen() == KErrNone);			

#endif

				TestMediaAccess(KErrNotReady, EFalse);				// Power up responds with KErrNotReady

#endif

				/**

	    		 * Test4 - Simulate door closed (with media present)

				 *		 - Power up responds with KErrNone

				 */

	    		NextTest(_L("Insert Media..."), cycles);

#ifndef __MANUAL_TEST__

				test(TheMediaChange.DoorClose(ETrue) == KErrNone);

#endif

				TestMediaAccess(KErrNone, ETrue);

				++cycles;

				}

			test.Console()->SetPos(0, 27);

#if !defined(__SOAK_TEST__) && !defined(__MANUAL_TEST__)

			t.Close();

#endif

			}

		else if(r == KErrNotSupported)

			{

			test.Printf(_L("Media change simulation not supported"));

			}

		/**

		 * Tidy up and exit

		 */

		test.Next(_L("\r\nClose device"));

		TheMediaChange.Close();

		test.Next(_L("Free device"));

		r=User::FreeLogicalDevice(_L("MedCh"));

		test(r == KErrNone);

		b.Format(_L("\r\nDisconnect from local drive %d "), drive);

		test.Next(b);

		TheDrive.Disconnect();

		}

	test.End();

	return(0);

	}