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

 // Component test of Publish and Subscribe

 // 

 //

 /**

  @file

  @internalTechnology

 */

 #include <f32file.h>

 #include <e32test.h>

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32svr.h>

 #include <hal.h>

 #include <massstorage.h>

 #include "t_ms_main.h"

 #include "testusbc.h"

 #include "scsicmdbuilder.h"

 #include "cstatemachine.h"

 #include "cpropertywatch.h"

 GLREF_D TBuf8<KScsiCmdMaxLen> scsiCmdBuf;

 GLREF_D RDevTestUsbcClient usbcClient;

 RFs fs;

 LOCAL_D TChar driveLetter;

 GLDEF_D TInt removalDrvNo;

 GLDEF_D TUint8 testLun(0);                // Use MMC card for testing

 _LIT(KMsFs, "MassStorageFileSystem");

 #define LOG_AND_TEST(a, e) {if (a!=e) {test.Printf(_L("lvalue %d, rvalue%d\n\r"), a,e); test(EFalse);}}

 LOCAL_C void ParseCommandArguments()

 //

 // Parses the command line arguments

 //

 	{

 	TBuf<0x100> cmd;

 	User::CommandLine(cmd);

 	TLex lex(cmd);

 	TPtrC token;

 	token.Set(lex.NextToken());

 	if (token.Length() != 0)

 		{

 		driveLetter = token[0];

 		driveLetter.UpperCase();

 		test.Printf(_L("CmdLine Param=%S"),&token);

 		}

 	else

 		{

 		test.Printf(_L("No or not enough command line arguments"));

 		// code drive letters based on platform

 		TInt uid;

 		TInt r=HAL::Get(HAL::EMachineUid,uid);

 		LOG_AND_TEST(r,KErrNone);

 		switch(uid)

    			{

    			case HAL::EMachineUid_Lubbock:

    				driveLetter = 'F';

    				test.Printf(_L("Test is running on Lubbock\r\n"));

 				testLun = 2;

 				break;

    			case HAL::EMachineUid_Win32Emulator:

    				driveLetter = 'X';

    				test.Printf(_L("Test is running on Win32 Emulator\r\n"));

 				testLun = 0;

    				break;

    			default:

 				// Assume it's a H2 board for now as no relevant Enum is found

    				driveLetter = 'D';

    				test.Printf(_L("Test is running on H2 board\r\n"));	

    				testLun = 0;				

    				break;

    			}

    		}	

 	}

 LOCAL_C void doComponentTest()

     //

     // Do the component test

     //

 	{

 #ifndef __NO_HEAP_CHECK

 	__UHEAP_MARK;

 #endif	

     TInt ret;

     test.Printf(_L("Start MountStart test. Be sure MMC card is inserted.\n"));

     // Parse the CommandLine argument: removal drive

     ParseCommandArguments();

     // Connect to the server

     LOG_AND_TEST(KErrNone,  fs.Connect());

 	CleanupClosePushL(fs); 

     // Convert drive letter to its numerical equivalent

 	ret = fs.CharToDrive(driveLetter,removalDrvNo);

 	LOG_AND_TEST(ret,  KErrNone);	

 	// Load the logical device

 	_LIT(KDriverFileName,"TESTUSBC.LDD");

 	ret = User::LoadLogicalDevice(KDriverFileName);

 	LOG_AND_TEST(KErrNone, ret);

     // Add MS file system

 	_LIT(KMsFsFsy, "MSFS.FSY");

 	LOG_AND_TEST(KErrNone, fs.AddFileSystem(KMsFsFsy));

     // Start Ms file system

     RUsbMassStorage usbMs;

     CleanupClosePushL(usbMs);

     TMassStorageConfig config;

     config.iVendorId.Copy(_L("vendorId"));

     config.iProductId.Copy(_L("productId"));

     config.iProductRev.Copy(_L("rev"));

 	ret = usbMs.Connect();

     LOG_AND_TEST(KErrNone, ret);

     // Start usb mass storage device

     LOG_AND_TEST(KErrNone , usbMs.Start(config));

     // Format removable drive using FAT FS

     RFormat format;

     TBuf<2> removalDrive;

     removalDrive.Append(driveLetter);

     removalDrive.Append(':');

     TInt tracksRemaining;

     test.Printf(_L("Start MMC card formatting\n"));

     LOG_AND_TEST(KErrNone, format.Open(fs, removalDrive, EHighDensity|EQuickFormat, tracksRemaining));

     while (tracksRemaining)

         {

         test.Printf(_L("."));

         LOG_AND_TEST(KErrNone,  format.Next(tracksRemaining));

         }

     format.Close();

   	test.Printf(_L("\nDone!\n"));

     // Open a session to LDD

     test.Printf(_L("Open LDD\n"));

     LOG_AND_TEST(KErrNone, usbcClient.Open(0));

 	test.Printf(_L("Creating CActiveScheduler\n"));

 	CActiveScheduler* sched = new(ELeave) CActiveScheduler;

 	CleanupStack::PushL(sched);

 	CActiveScheduler::Install(sched);

 	// Create a state machine

 	CStateMachine* sm = CStateMachine::NewL();

 	CleanupStack::PushL(sm);

     sm->AddState(EUsbMsDriveState_Disconnected);

     sm->AddState(EUsbMsDriveState_Connecting);

     sm->AddState(EUsbMsDriveState_Connected);

     sm->AddState(EUsbMsDriveState_Disconnecting);

     sm->AddState(EUsbMsDriveState_Active);

     sm->AddState(EUsbMsDriveState_Locked);

     sm->AddState(EUsbMsState_Written);

     sm->AddState(EUsbMsState_Read);

     sm->SetInitState(EUsbMsDriveState_Disconnected);

   	CPropertyHandler* driveStatusHandler 	= CMsDriveStatusHandler::NewLC(removalDrvNo, *sm);

   	CPropertyHandler* readStatusHandler 	= CMsReadStatusHandler::NewLC(removalDrvNo, *sm);

   	CPropertyHandler* writtenStatusHandler 	= CMsWrittenStatusHandler::NewLC(removalDrvNo, *sm);

  	CPropertyWatch::NewLC(EUsbMsDriveState_DriveStatus, *driveStatusHandler);

  	CPropertyWatch::NewLC(EUsbMsDriveState_KBytesRead, *readStatusHandler);

  	CPropertyWatch::NewLC(EUsbMsDriveState_KBytesWritten, *writtenStatusHandler);

 	CActiveScheduler::Start();

 	ret = usbMs.Stop();

 	test.Printf(_L("usbMs.Stop returned %d\n"), ret);

 	test(ret == KErrNone);

 	usbMs.Close();

 	// 1 sec delay for MSFS to stop

 	User::After(1000000);

 	ret = fs.RemoveFileSystem(KMsFs);

 	test(ret == KErrNone || ret == KErrNotFound);

 	test.Printf(_L("RemoveFileSystem returned %d\n"), ret);

 	usbcClient.Close();

 	ret = User::FreeLogicalDevice(_L("USBC"));

 	test.Printf(_L("FreeLogicalDevice returned %d\n"), ret);

 	test(ret == KErrNone);			

 	CleanupStack::PopAndDestroy(3);	// 3 CPropertyWatches 

 	CleanupStack::PopAndDestroy(3);	// 3 property status change handlers

 	CleanupStack::PopAndDestroy(sm);

 	CleanupStack::PopAndDestroy(sched);

 	CleanupStack::PopAndDestroy(&usbMs);

 	CleanupStack::PopAndDestroy(&fs);

 #ifndef __NO_HEAP_CHECK

 	__UHEAP_MARKEND;

 #endif

 	}

 GLDEF_C void CallTestsL()

 //

 // Do all tests

 //

 	{

 	test.Start( _L("Test Publish Subscriber") );

     doComponentTest();

     test.End();

     }