// 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:

// file: t_ms_scsi_steps.cpp

// SCSI protocol test cases.

// 

//

/**

 @file

 @internalTechnology

*/

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include <f32fsys.h>

#include "massstoragedebug.h"

#include "t_ms_main.h"

#include "t_ms_scsi.h"

TInt CScsiTest::TestLun = 1;

// see scsiprot.cpp

LOCAL_D const TUint KDefaultBlockSize = 0x200;

LOCAL_D TBool mediaChanged = EFalse;

LOCAL_D const TInt KMaxLuns = 8;

/**

t_scsi_inquiry_normal case

*/

GLDEF_C void t_scsi_inquiry_normal()

	{

	test.Next(_L("t_scsi_inquiry_normal"));

	CScsiTest* scsiTest = CScsiTest::NewLC();

	TMassStorageConfig config;

	config.iVendorId.FillZ(8);

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

	config.iVendorId.SetLength(8);

	config.iProductId.FillZ(16);

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

	config.iProductId.SetLength(16);

	config.iProductRev.FillZ(4);

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

	config.iProductRev.SetLength(4);

	TEST_FOR_VALUE (scsiTest->iScsiProt->SetScsiParameters(config), KErrNone);

	TInquiryCmd cmd;

	TPtrC8 pBuf(cmd.iCmd);

	// CASE: media is Not connected

	TEST_FOR_VALUE (scsiTest->DecodePacket(pBuf), ETrue);

	{

	TInquiryData inquiryData(scsiTest->iTransport.iBufWrite);

	// test 		value					expected

	TEST_FOR_VALUE (inquiryData.DeviceType(),	0);

	TEST_FOR_VALUE (inquiryData.RMB(), 			1);

	TEST_FOR_VALUE (inquiryData.Version(), 		0);

	TEST_FOR_VALUE (inquiryData.RespDataFrmt(),	0x02);

	TEST_FOR_VALUE (inquiryData.PeripheralQualifier(), 0);	// to be 'connected'

	TEST_FOR_VALUE ((35 <= inquiryData.Length()),ETrue);		// at least min length

	// these values were set above in this function

	TMassStorageConfig configInquiry;

	configInquiry.iVendorId.Copy(inquiryData.VendorId());

	configInquiry.iProductId.Copy(inquiryData.ProductId());

	configInquiry.iProductRev.Copy(inquiryData.RevisionLevel());

	__PRINT1 (_L("VendorId: %S\n"), &configInquiry.iVendorId);

	__PRINT1 (_L("ProductId: %S\n"), &configInquiry.iProductId);

	__PRINT1 (_L("ProductRev: %S\n"), &configInquiry.iProductRev);

	TEST_FOR_VALUE((configInquiry.iVendorId == config.iVendorId),	ETrue);

	TEST_FOR_VALUE((configInquiry.iProductId == config.iProductId), 	ETrue);

	TEST_FOR_VALUE((configInquiry.iProductRev == config.iProductRev), ETrue);

	}

	__PRINT (_L("media not connected ===> passed OK\n"));

	// CASE: emulate 'mount and connect media'	

	// set connection to physical device as Connected

	scsiTest->MountTestDrive();

	TEST_FOR_VALUE (scsiTest->DecodePacket(pBuf), ETrue);

	{

	TInquiryData inquiryData(scsiTest->iTransport.iBufWrite);

	TEST_FOR_VALUE(inquiryData.PeripheralQualifier(), 0);	// to be 'connected'

	}

	__PRINT (_L("media not connected ===> passed OK\n"));

	// cleanup

	CleanupStack::PopAndDestroy(1); // scsiTest

	__PRINT (_L("t_scsi_inquiry_normal ===> passed OK\n"));

	}

/**

t_scsi_inquiry_error case

*/

GLDEF_C void t_scsi_inquiry_error()

	{

	test.Next(_L("t_scsi_inquiry_error"));

	CScsiTest* scsiTest = CScsiTest::NewLC();

	TInquiryCmd cmd;

	cmd.iCmd[2] = 0x02; 	// set CmdDt = 1 (2nd bit in 2nd byte)

	TPtrC8 pBuf(cmd.iCmd);

	TEST_FOR_VALUE(scsiTest->DecodePacket(pBuf), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);

	// cleanup

	CleanupStack::PopAndDestroy(1); // scsiTest

	__PRINT (_L("t_scsi_inquiry_error ===> passed OK\n"));

	}

/**

t_scsi_test_unit_ready case

*/

GLDEF_C void t_scsi_test_unit_ready()

	{

	test.Next(_L("t_scsi_test_unit_ready"));

	CScsiTest* scsiTest = CScsiTest::NewLC();

	// CASE: NOT registered media

	TTestUnitReadyCmd cmd;

	TPtrC8 pBuf(cmd.iCmd);

	TEST_FOR_VALUE (scsiTest->DecodePacket(pBuf), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(),

						TSenseInfo::ENotReady,

						TSenseInfo::EMediaNotPresent);

	// CASE: registered media

	scsiTest->MountTestDrive();

	// repeat TEST UNIT READY command

	TEST_FOR_VALUE(scsiTest->DecodePacket(pBuf), ETrue);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::ENoSense, 0);

	// cleanup

	CleanupStack::PopAndDestroy(1); // scsiTest

	__PRINT (_L("t_scsi_test_unit_ready ===> passed OK\n"));

	}

/**

t_scsi_prevent_allow_media_removal case

*/

GLDEF_C void t_scsi_prevent_allow_media_removal()

	{

	test.Next(_L("t_scsi_prevent_allow_media_removal"));

	CScsiTest* scsiTest = CScsiTest::NewLC();

	// SPC-2, p. 113

	// Notes: limitation in SCSI protocol:

	// SCSI protocol uses the 1st bit of PREVENT field only 

	TMediaRemovalCmd cmdAllow;

	cmdAllow.iCmd[5] = 0x00;		// allow

	TPtrC8 pCmdAllow(cmdAllow.iCmd);

	TMediaRemovalCmd cmdPrevent;

	cmdPrevent.iCmd[5] = 0x01;	// prevent

	TPtrC8 pCmdPrevent(cmdPrevent.iCmd);

	// CASE: do NOT register media AND allow media removal

	TEST_FOR_VALUE(scsiTest->DecodePacket(pCmdAllow), EFalse);

	TEST_SENSE_CODE_IF_SUPPORTED(scsiTest->GetSenseCodePtr(), TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent)

		{

		 __PRINT(_L("NOT register media AND allow removal ===> passed OK\n"));

		// CASE: do NOT register media AND prevent media removal

		TEST_FOR_VALUE(scsiTest->DecodePacket(pCmdPrevent), EFalse);

		TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);

		 __PRINT(_L("NOT register media AND prevent removal ===> passed OK\n"));

		// CASE: Register media AND prevent removal 

		scsiTest->MountTestDrive();

		TEST_FOR_VALUE(scsiTest->DecodePacket(pCmdPrevent), ETrue);

		// check setting in a Drive. the drive has to set to Active state

		TEST_FOR_VALUE(scsiTest->TestDrive()->DriveState(),	CMassStorageDrive::EActive);

		 __PRINT(_L("Register media AND prevent removal ===> passed OK\n"));

		// CASE:Register media AND allow removal

		TEST_FOR_VALUE(scsiTest->DecodePacket(pCmdAllow), ETrue);

		// check setting in a Drive. the drive has to set to Idle state

		TEST_FOR_VALUE(scsiTest->TestDrive()->DriveState(),	CMassStorageDrive::EIdle);

		 __PRINT(_L("Register media AND allow removal ===> passed OK\n"));

		}

	// cleanup

	CleanupStack::PopAndDestroy(1); // scsiTest

	 __PRINT(_L("t_scsi_prevent_allow_media_removal ===> passed OK\n"));

	}

/**

t_scsi_start_stop_unit case

*/

GLDEF_C void t_scsi_start_stop_unit()

	{

	test.Next(_L("t_scsi_start_stop_unit\n"));

	CScsiTest* scsiTest = CScsiTest::NewLC();

	// SBC-2, p. 64 of scsi block commands spec

	// Notes: limitation in SCSI protocol:

	// SCSI protocol doesn't support the following fields:

	// -- IMMED

	// -- POWER CONDITIONS

	// => the supported fields are

	// -- START

	// -- LOEJ

	TBuf8<7> cmdStart;

	cmdStart.FillZ(7);

	cmdStart[0] = 0x06;		// size of a command itself

	cmdStart[1] = 0x1B; 	// START STOP UNIT command

	cmdStart[2] = 0x01;		// Get result immediatly

	cmdStart[5] = 0x03;		// start: LOEJ + START

	TPtrC8 pCmdStart(cmdStart);

	TBuf8<7> cmdStop;

	cmdStop.FillZ(7);

	cmdStop[0] = 0x06;		// size of a command itself

	cmdStop[1] = 0x1B; 		// START STOP UNIT command

	cmdStop[2] = 0x01;		// Get result immediatly

	cmdStop[5] = 0x02;		// stop: LOEJ

	TPtrC8 pCmdStop(cmdStop);

	// CASE: do NOT register media AND Start

	// NOT APPLICABLE as there is no such thing as 'register media' in latest implementation

	// CASE: do NOT register media AND stop

	// NOT APPLICABLE as there is no such thing as 'register media' in latest implementation

	// CASE: Start unit

	TEST_FOR_VALUE(scsiTest->DecodePacket(pCmdStart), ETrue);

	// check setting in a Drive. the drive has to set to Connecting state

	TEST_FOR_VALUE (scsiTest->TestDrive()->MountState(), CMassStorageDrive::EConnecting);

	 __PRINT(_L("Registered media AND Start unit ===> passed OK\n"));

 	// CASE: Stop unit

	TEST_FOR_VALUE(scsiTest->DecodePacket(pCmdStop), ETrue);

	// check setting in a Drive. the drive has to set to Disconnecting state

	TEST_FOR_VALUE(scsiTest->TestDrive()->MountState(),		CMassStorageDrive::EDisconnecting);

	 __PRINT(_L("Registered media AND stop unit ===> passed OK\n"));

	// cleanup

	CleanupStack::PopAndDestroy(1); // scsiTest

	 __PRINT(_L("t_scsi_start_stop_unit ===> passed OK\n"));

	}

/**

t_scsi_request_sense case

*/

GLDEF_C void t_scsi_request_sense()

	{

	test.Next(_L("t_scsi_request_sense\n"));

	CScsiTest* scsiTest = CScsiTest::NewLC();

	// -- check sense BEFORE any other command

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::ENoSense, 0);

	// CASE: don't register drive and send UNIT READY

	TTestUnitReadyCmd cmdUnitReady;

	TPtrC8 pRequestSenseCmd (cmdUnitReady.iCmd);

	TEST_FOR_VALUE (scsiTest->DecodePacket (pRequestSenseCmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);

	// check sense code right away

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::ENoSense, 0);

	// CASE: do register media

	scsiTest->MountTestDrive();

	// repeat TEST UNIT READY command

	TEST_FOR_VALUE (scsiTest->DecodePacket(pRequestSenseCmd), ETrue);

	// CASE: deregister media

	scsiTest->DismountTestDrive();

	TEST_FOR_VALUE (scsiTest->DecodePacket(pRequestSenseCmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);

	// check sense code right away

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::ENoSense, 0);

	// cleanup

	CleanupStack::PopAndDestroy(1); // scsiTest

	 __PRINT(_L("t_scsi_request_sense ===> passed OK\n"));

	}

/**

t_scsi_read case

*/

GLDEF_C void t_scsi_read()

	{

	test.Next (_L("t_scsi_read\n"));

	CScsiTest* scsiTest = CScsiTest::NewLC();

	// and initialize proxy drive buffers

	scsiTest->iProxyDrive.Initialise();

	// SBC-2 p.50

	// dev notes: latest implementation of scsi protocol supports only:

	//			- Logical block address

	//			- Transfer length

	//			- RDPROTECT (only true or false)

	//     all other fields are not supported

	TReadWrite10Cmd cmd;

	cmd.SetRead();	// setup cmd with correct header

	TPtrC8 pRead10Cmd(cmd.iCmd);

	// extra check for iMediaBuf

	ASSERT (scsiTest->iProxyDrive.iMediaBuf.Length() / KDefaultBlockSize < 0x0000FFFF);

	TUint16 maxNumBlocks = static_cast<TUint16>(scsiTest->iProxyDrive.iMediaBuf.Length() / KDefaultBlockSize);

	TUint16 readBlocks = 1;

	TUint32 offsetBlocks = 1;

	// CASE: register drive; nothing to read

	scsiTest->MountTestDrive();

	TEST_FOR_VALUE(scsiTest->DecodePacket(pRead10Cmd), ETrue);

	 __PRINT(_L("Request to read 0 bytes ===> passed OK\n"));

	// CASE: read min (1 block) with offset = 0

	readBlocks = 1;

	cmd.SetTransferLength (readBlocks);

	cmd.SetBlockAddress(0);

	TEST_FOR_VALUE(scsiTest->DecodePacket(pRead10Cmd), ETrue);

	{

	TPtrC8 transportBuf = scsiTest->iTransport.iBufWrite.Left(readBlocks * KDefaultBlockSize);

	TPtrC8 driveBuf(TPtrC8(scsiTest->iProxyDrive.iMediaBuf).Left(readBlocks * KDefaultBlockSize));

	// data should be identical

	TEST_FOR_VALUE(driveBuf.Compare(transportBuf), 0);

	}

	 __PRINT(_L("Request to read 1 block @ offset 0 ===> passed OK\n"));

	// CASE: read after the end

	readBlocks = 10;

	cmd.SetTransferLength (readBlocks);

	cmd.SetBlockAddress(maxNumBlocks - readBlocks/2);

	TEST_FOR_VALUE(scsiTest->DecodePacket(pRead10Cmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::EIllegalRequest, TSenseInfo::ELbaOutOfRange);

	 __PRINT(_L("Request to read AFTER the end of a media ===> passed OK\n"));

	// CASE: read from after the end

	readBlocks = 10;

	cmd.SetTransferLength (readBlocks);

	cmd.SetBlockAddress(maxNumBlocks + readBlocks/2);

	TEST_FOR_VALUE(scsiTest->DecodePacket(pRead10Cmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::EIllegalRequest, TSenseInfo::ELbaOutOfRange);

	 __PRINT(_L("Request to start read AFTER the end of a media ===> passed OK\n"));

	// CASE: check for internal buffer overflow (with offset)

	// dev note: this check is specific to SCSI prot implementation

	// 			 and NOT described by SBC-2 

	offsetBlocks = 1;

	readBlocks = static_cast<TUint16>(maxNumBlocks - offsetBlocks);

	cmd.SetTransferLength (readBlocks);

	cmd.SetBlockAddress(offsetBlocks);

	TEST_FOR_VALUE(scsiTest->DecodePacket(pRead10Cmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);

	 __PRINT(_L("Check for internal buffer overflow ===> passed OK\n"));

	// CASE: read max with offset (= offsetBlocks block)

	offsetBlocks = 2;

	//				max size in blocks supported by SCSI prot  - offsetBlocks

	readBlocks = static_cast<TUint16>((KMaxBufSize / KDefaultBlockSize) - offsetBlocks);

	cmd.SetTransferLength (readBlocks);

	cmd.SetBlockAddress(offsetBlocks);

	TEST_FOR_VALUE(scsiTest->DecodePacket(pRead10Cmd), ETrue);

	{

	TPtrC8 transportBuf (scsiTest->iTransport.iBufWrite.Left(readBlocks * KDefaultBlockSize));

	TPtrC8 driveBuf(TPtrC8(scsiTest->iProxyDrive.iMediaBuf).Mid(offsetBlocks * KDefaultBlockSize, readBlocks * KDefaultBlockSize));

	// data should be identical

	TEST_FOR_VALUE(driveBuf.Compare(transportBuf), 0);

	}

	 __PRINT(_L("Check for max read ===> passed OK\n"));

	// CASE: boundary conditions

	offsetBlocks = 0xFFFFFFFF;

	readBlocks = 0xFFFF;

	cmd.SetTransferLength (readBlocks);

	cmd.SetBlockAddress(offsetBlocks);

	TEST_FOR_VALUE(scsiTest->DecodePacket(pRead10Cmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::EIllegalRequest, TSenseInfo::ELbaOutOfRange);

	 __PRINT(_L("Check for boundary conditions ===> passed OK\n"));

	// CASE: try RDProtect

	// dev note: scsi protocol doesn't support any value except 000b

	cmd.SetProtect (1);

	offsetBlocks = 1;

	readBlocks = 1;

	cmd.SetTransferLength (readBlocks);

	cmd.SetBlockAddress(offsetBlocks);

	TEST_FOR_VALUE(scsiTest->DecodePacket(pRead10Cmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::EIllegalRequest, TSenseInfo::EInvalidFieldInCdb);

	 __PRINT(_L("Check for RD Protect ===> passed OK\n"));

	// CASE: invalid CAPs

	cmd.SetProtect (0);

	offsetBlocks = 1;

	readBlocks = 1;

	cmd.SetTransferLength (readBlocks);

	cmd.SetBlockAddress (offsetBlocks);

	// create error conditions in drive

	TInt error = KErrNone;

	CMassStorageDrive* pDrive = scsiTest->iDriveManager->Drive (CScsiTest::TestLun, error);

	ASSERT (KErrNone == error && pDrive);

	delete pDrive->iLocalDrive;

	pDrive->iLocalDrive = NULL;

	TEST_FOR_VALUE (scsiTest->DecodePacket (pRead10Cmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::ENotReady, TSenseInfo::EMediaNotPresent);

	 __PRINT(_L("Check for invalid caps ===> passed OK\n"));

	// NOTE: be aware that CMassStorageDrive is in invalid state at this point 

	//		as Drive->iLocalDrive was set to NULL

	// cleanup

	CleanupStack::PopAndDestroy (1); // scsiTest

	 __PRINT(_L("t_scsi_read ===> passed OK\n"));

	}

/**

t_scsi_write case

*/

GLDEF_C void t_scsi_write()

	{

	test.Next (_L("t_scsi_write\n"));

	CScsiTest* scsiTest = CScsiTest::NewLC();

	// and initialize Read/Write buffers

	scsiTest->iProxyDrive.Initialise();

	scsiTest->iTransport.InitialiseReadBuf();

	// SBC-2 p.80

	// dev notes: latest implementation of scsi protocol supports only:

	//			- Logical block address

	//			- Transfer length

	//			- WRPROTECT (only true or false)

	//     all other fields are not supported

	TReadWrite10Cmd cmd;

	cmd.SetWrite(); // setup cmd with correct header

	TPtrC8 pWrite10Cmd(cmd.iCmd);

	TUint16 maxNumBlocks = static_cast<TUint16>(scsiTest->iProxyDrive.iMediaBuf.Length() / KDefaultBlockSize);

	TUint16 writeBlocks = 1;

	TUint32 offsetBlocks = 1;

	// CASE: register drive; nothing to read

	scsiTest->MountTestDrive();

	TEST_FOR_VALUE(scsiTest->DecodePacket (pWrite10Cmd), ETrue);

	 __PRINT(_L("Request to write 0 bytes ===> passed OK\n"));

	// CASE: write min

	writeBlocks = 1;

	cmd.SetTransferLength (writeBlocks);

	cmd.SetBlockAddress(0);

	TEST_FOR_VALUE(scsiTest->DecodePacket (pWrite10Cmd), ETrue);

	// complete read

	TEST_FOR_VALUE(scsiTest->iScsiProt->ReadComplete(KErrNone), KErrNone);

	{

	// note: offset == 0 in this case

	TPtrC8 transportBuf = scsiTest->iTransport.iBufRead.Left(writeBlocks * KDefaultBlockSize);

	TPtrC8 driveBuf(TPtrC8(scsiTest->iProxyDrive.iMediaBuf).Mid(0, writeBlocks * KDefaultBlockSize));

	// data should be identical

	TEST_FOR_VALUE (driveBuf.Compare(transportBuf), 0);

	}

	 __PRINT(_L("Request to write 1 block @ offset 0 ===> passed OK\n"));

	// CASE: 	KMediaAttWriteProtected

	scsiTest->iProxyDrive.iCaps.iMediaAtt = KMediaAttWriteProtected;

	cmd.SetTransferLength (1);

	cmd.SetBlockAddress (0);

	TEST_FOR_VALUE (scsiTest->DecodePacket (pWrite10Cmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::EDataProtection, TSenseInfo::EWriteProtected);

	// and CASE: KMediaAttLocked

	scsiTest->iProxyDrive.iCaps.iMediaAtt = KMediaAttLocked;

	TEST_FOR_VALUE (scsiTest->DecodePacket (pWrite10Cmd), EFalse);

	TEST_SENSE_CODE (scsiTest->GetSenseCodePtr(), TSenseInfo::EDataProtection, TSenseInfo::EWriteProtected);

	// restore media attributes