Symaptic: os/kernelhwsrv/kerneltest/f32test/smassstorage/msdrive/t

     1 // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Unit tests for the CMassStorageDrive and CDriveManager classes

    15 //

    16 //

    18 /**

    19  @file

    20  @internalTechnology

    21 */

    23 #include <e32std.h>

    24 #include <e32std_private.h>

    25 #include <e32twin.h>

    26 #include <e32test.h>

    27 #include <e32property.h>

    29 #include "usbmsshared.h"

    30 #include "drivemanager.h"

    33 enum TestStep

    34 	{

    35 	EStepRead0,

    36 	EStepRead1,

    37 	EStepWrite0,

    38 	EStepWrite1,

    39 	EStepConnected,

    40 	EStepActive,

    41 	EStepMediaRemoved,

    42 	EStepLocked,

    43 	EStepDisconnecting,

    44 	EStepDisconnected,

    45 	EStepConnecting

    46 	};

    48 LOCAL_D RTest test(_L("MSDRIVE"));

    49 LOCAL_D const TDriveNumber gDrive1 = EDriveL; // used drive

    50 LOCAL_D const TDriveNumber gDrive2 = EDriveN; // unused drive

    51 LOCAL_D CDriveManager* gMgr = NULL;

    52 LOCAL_D TestStep gTestStep = EStepRead0;

    54 #define NEXT(x) test.Next(_L(#x)); gTestStep = x;

    57 /**

    58 These CProxyDrive functions are copies of code in sf_ext.cpp,

    59 since we don't link to EFILE.

    60 */

    61 CProxyDrive::CProxyDrive(CMountCB* aMount) : iMount(aMount) {}

    63 EXPORT_C TInt CProxyDrive::ControlIO(

    64 		const RMessagePtr2& /*aMessage*/,

    65 		TInt /*aCommand*/,TAny* /*aParam1*/,TAny* /*aParam2*/)

    66 	{

    67 	return(KErrNone);

    68 	}

    70 EXPORT_C TInt CProxyDrive::DeleteNotify(TInt64 /*aPos*/, TInt /*aLength*/)

    71 	{

    72 	return(KErrNone);

    73 	}

    75 EXPORT_C TInt CProxyDrive::GetInterface(TInt /*aInterfaceId*/, TAny*& /*aInterface*/, TAny* /*aInput*/)

    76 	{ return KErrNotSupported; }

    78 // Implemented the GetLastErrorInfo method here as this is usually

    79 // exported by EFILE, but these unit tests don't link to it.

    80 EXPORT_C TInt CProxyDrive::GetLastErrorInfo(TDes8& /*anErrorInfo*/)

    81 	{ return KErrNotSupported; }

    83 CProxyDrive::~CProxyDrive()

    84 	{

    85 	}

    87 EXPORT_C TInt CProxyDrive::Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt /*aThreadHandle*/, TInt /*aOffset*/, TInt /*aFlags*/)

    88 	{

    89 	return Read(aPos, aLength, *(TDes8*)aTrg);

    90 	}

    92 EXPORT_C TInt CProxyDrive::Write(TInt64 aPos, TInt /*aLength*/, const TAny* aSrc, TInt /*aThreadHandle*/, TInt /*aOffset*/, TInt /*aFlags*/)

    93 	{

    94 	return Write(aPos, *(TDesC8*)aSrc);

    95 	}

    97 /**

    98 CMassStorageMountCB gets the CProxyDrive from the filesystem,

    99 but here we want to instantiate our own derived class for testing.

   100 This allows us to control the error code returned by each function.

   101 */

   102 class CTestProxyDrive : public CProxyDrive

   103 	{

   104 public:

   105 	static TInt iRetval;

   106 	static TInt iRetval_caps;

   107 	static TLocalDriveCapsV4 iCaps;

   109 	CTestProxyDrive(CDriveManager& aDriveManager) : CProxyDrive(NULL)

   110 		{

   111 		iCaps.iType = ::EMediaUnknown;

   113 		iWriteTransferPublisher = CDriveWriteTransferPublisher::NewL(aDriveManager.iDrives);

   114 		iReadTransferPublisher = CDriveReadTransferPublisher::NewL(aDriveManager.iDrives);

   115 		}

   117 	~CTestProxyDrive()

   118 		{

   119 		delete iWriteTransferPublisher;

   120 		delete iReadTransferPublisher;

   121 		}

   122 	virtual TInt Initialise()

   123 		{

   124 		return iRetval;

   125 		}

   126 	virtual TInt Dismounted()

   127 		{

   128 		return iRetval;

   129 		}

   130 	virtual TInt Enlarge(TInt )

   131 		{

   132 		return iRetval;

   133 		}

   134 	virtual TInt ReduceSize(TInt , TInt )

   135 		{

   136 		return iRetval;

   137 		}

   138 	virtual TInt Read(TInt64 ,TInt ,const TAny* ,TInt ,TInt )

   139 		{

   140 		iReadTransferPublisher->StartTimer();

   141 		return iRetval;

   142 		}

   143 	virtual TInt Read(TInt64 ,TInt len, TDes8& buf)

   144 		{

   145 		iReadTransferPublisher->StartTimer();

   146 		buf.SetLength(len);

   147 		return iRetval;

   148 		}

   149 	virtual TInt Write(TInt64 ,TInt ,const TAny* ,TInt ,TInt )

   150 		{

   151 		iWriteTransferPublisher->StartTimer();

   152 		return iRetval;

   153 		}

   154 	virtual TInt Write(TInt64 ,const TDesC8& )

   155 		{

   156 		iWriteTransferPublisher->StartTimer();

   157 		return iRetval;

   158 		}

   159 	virtual TInt Caps(TDes8& aBuf)

   160 		{

   161 		((TLocalDriveCapsV4Buf&)aBuf) = iCaps;

   163 		return iRetval_caps;

   164 		}

   165 	virtual TInt Format(TFormatInfo& )

   166 		{

   167 		return iRetval;

   168 		}

   169 	virtual TInt Format(TInt64 ,TInt )

   170 		{

   171 		return iRetval;

   172 		}

   173 	virtual TInt SetMountInfo(const TDesC8* ,TInt )

   174 		{

   175 		return iRetval;

   176 		}

   177 	virtual TInt ForceRemount(TUint )

   178 		{

   179 		return iRetval;

   180 		}

   181 	virtual TInt Unlock(TMediaPassword &, TBool )

   182 		{

   183 		return iRetval;

   184 		}

   185 	virtual TInt Lock(TMediaPassword &, TMediaPassword &, TBool )

   186 		{

   187 		return iRetval;

   188 		}

   189 	virtual TInt Clear(TMediaPassword &)

   190 		{

   191 		return iRetval;

   192 		}

   193 	virtual TInt ErasePassword()

   194 		{

   195 		return iRetval;

   196 		}

   198 private:

   199 	/**

   200 	Publish and subscribe properties for tracking data transfer volume

   201 	*/

   202 	CDriveWriteTransferPublisher* iWriteTransferPublisher;

   203 	CDriveReadTransferPublisher* iReadTransferPublisher;

   204 	};

   206 TInt CTestProxyDrive::iRetval = KErrNone;

   207 TInt CTestProxyDrive::iRetval_caps = KErrNone;

   208 TLocalDriveCapsV4 CTestProxyDrive::iCaps;

   210 /**

   211 From USBMSAPP:

   212 A set of static objects that hold the latest properties published by Mass Storage,

   213 and a set of corresponding static functions that process the publish events.

   214 The functions are passed by pointer to, and invoked by, CPropertyWatch instances.

   215 */

   216 class PropertyHandlers

   217 	{

   218 public:

   219 	/** The prototype for all public property handler functions */

   220 	typedef void(*THandler)(RProperty&);

   222 public:

   223 	static void Read(RProperty& aProperty);

   224 	static void Written(RProperty& aProperty);

   225 	static void DriveStatus(RProperty& aProperty);

   227 public:

   228 	static TBuf8<16> iAllDrivesStatus;

   229 	static TUsbMsBytesTransferred iKBytesRead;

   230 	static TUsbMsBytesTransferred iKBytesWritten;

   231 	};

   233 /**

   234 From USBMSAPP:

   235 An active object that subscribes to a specified Mass Storage property and

   236 calls a provided handler each time the property is published.

   237 */

   238 class CPropertyWatch : public CActive

   239 	{

   240 public:

   241 	static CPropertyWatch* NewLC(TUsbMsDriveState_Subkey aSubkey, PropertyHandlers::THandler aHandler);

   242 private:

   243 	CPropertyWatch(PropertyHandlers::THandler aHandler);

   244 	void ConstructL(TUsbMsDriveState_Subkey aSubkey);

   245 	~CPropertyWatch();

   246 	void RunL();

   247 	void DoCancel();

   248 private:

   249 	RProperty iProperty;

   250 	PropertyHandlers::THandler iHandler;

   251 	};

   253 CPropertyWatch* CPropertyWatch::NewLC(TUsbMsDriveState_Subkey aSubkey, PropertyHandlers::THandler aHandler)

   254 	{

   255 	CPropertyWatch* me=new(ELeave) CPropertyWatch(aHandler);

   256 	CleanupStack::PushL(me);

   257 	me->ConstructL(aSubkey);

   258 	return me;

   259 	}

   261 CPropertyWatch::CPropertyWatch(PropertyHandlers::THandler aHandler)

   262 	: CActive(0), iHandler(aHandler)

   263 	{}

   265 void CPropertyWatch::ConstructL(TUsbMsDriveState_Subkey aSubkey)

   266 	{

   267 	User::LeaveIfError(iProperty.Attach(KUsbMsDriveState_Category, aSubkey));

   268 	CActiveScheduler::Add(this);

   269 	// initial subscription and process current property value

   270 	RunL();

   271 	}

   273 CPropertyWatch::~CPropertyWatch()

   274 	{

   275 	Cancel();

   276 	iProperty.Close();

   277 	}

   279 void CPropertyWatch::DoCancel()

   280 	{

   281 	iProperty.Cancel();

   282 	}

   284 void CPropertyWatch::RunL()

   285 	{

   286 	// resubscribe before processing new value to prevent missing updates

   287 	iProperty.Subscribe(iStatus);

   289 	iHandler(iProperty);

   291 	SetActive();

   292 	}

   295 TBuf8<16> PropertyHandlers::iAllDrivesStatus;

   296 TUsbMsBytesTransferred PropertyHandlers::iKBytesRead;

   297 TUsbMsBytesTransferred PropertyHandlers::iKBytesWritten;

   300 /**

   301 Handle a publish event for the Bytes Read property.

   302 */

   303 void PropertyHandlers::Read(RProperty& aProperty)

   304 	{

   305 	const TUint KNoBytesToRead = 1000;

   306 	test(aProperty.Get(iKBytesRead)==KErrNone);

   307 	TInt kbytes = iKBytesRead[0];

   309 	TBuf8<KNoBytesToRead> buf;

   310 	buf.SetLength(KNoBytesToRead);

   311 	TInt err;

   313 	switch(gTestStep)

   314 		{

   315 		case EStepRead0:

   316 			// don't do anything until 1st KB reported in 1s interval

   317 			if(kbytes==0)

   318 				{

   319 				break;

   320 				}

   321 			test(kbytes==1);

   323 			test(KErrNone == gMgr->Drive(0,err)->Read(0,KNoBytesToRead,buf));

   324 			NEXT(EStepRead1);

   325 			break;

   327 		case EStepRead1:

   328 			test(kbytes==2);

   330 			// trigger an update:

   331 			test(KErrNone == gMgr->Drive(0,err)->Write(0,buf));

   332 			NEXT(EStepWrite0);

   333 			break;

   335 		default:

   336 			break;

   337 		}

   338 	}

   340 /**

   341 Handle a publish event for the Bytes Written property.

   342 */

   343 void PropertyHandlers::Written(RProperty& aProperty)

   344 	{

   345 	const TUint KNoBytesToWrite = 1000;

   346 	test(aProperty.Get(iKBytesWritten)==KErrNone);

   347 	TInt kbytes = iKBytesWritten[0];

   349 	TBuf8<KNoBytesToWrite> buf;

   350 	buf.SetLength(KNoBytesToWrite);

   351 	TInt err;

   353 	switch(gTestStep)

   354 		{

   355 		case EStepWrite0:

   356 			test(kbytes==2);

   358 			test(KErrNone == gMgr->Drive(0,err)->Write(0,buf));

   359 			NEXT(EStepWrite1);

   360 			break;

   362 		case EStepWrite1:

   363 			test(kbytes==3);

   365 			// trigger transient change to Active state:

   366 			test(KErrNone == gMgr->Drive(0,err)->Write(0,buf));

   367 			NEXT(EStepConnected);

   368 			break;

   370 		default:

   371 			break;

   372 		}

   373 	}

   375 /**

   376 Handle a publish event for the Drive Status property.

   377 */

   378 void PropertyHandlers::DriveStatus(RProperty& aProperty)

   379 	{

   380 	RDebug::Print(_L(">> PropertyHandlers::DriveStatus"));

   381 	TInt err = aProperty.Get(iAllDrivesStatus);

   382 	test(err == KErrNone);

   384 	// There should be status for 2 drives:

   385 	// (Note: there is a pair of bytes per drive,

   386 	// drive number and drive status.)

   387 	test(2 == iAllDrivesStatus.Length()/2);

   388 	test(iAllDrivesStatus[0] == gDrive1);

   389 	test(iAllDrivesStatus[2*1] == gDrive2);

   390 	TInt status = iAllDrivesStatus[1];

   392 	switch(gTestStep)

   393 		{

   394 		case EStepConnected:

   395 			test(status==EUsbMsDriveState_Connected);

   397 			test(KErrNone==gMgr->Drive(0,err)->SetCritical(ETrue));

   398 			NEXT(EStepActive);

   399 			break;

   401 		case EStepActive:

   402 			test(status==EUsbMsDriveState_Active);

   404 			CTestProxyDrive::iRetval_caps = KErrNotReady;

   405 			test(CMassStorageDrive::EMediaNotPresent

   406 					==gMgr->Drive(0,err)->CheckDriveState());

   407 			CTestProxyDrive::iRetval_caps = KErrNone;

   409 			NEXT(EStepMediaRemoved);

   410 			break;

   412 		case EStepMediaRemoved:

   413 			{

   414 			test(status==EUsbMsDriveState_MediaNotPresent);

   416 			gMgr->Drive(0,err)->CheckDriveState(); // clear old state

   418 			CTestProxyDrive::iRetval = KErrLocked;

   419 			TBuf8<1> buf;

   420 			buf.SetLength(1);

   421 			test(KErrLocked==gMgr->Drive(0,err)->Write(0,buf));

   422 			CTestProxyDrive::iRetval = KErrNone;

   423 			NEXT(EStepLocked);

   424 			}

   425 			break;

   427 		case EStepLocked:

   428 			test(status==EUsbMsDriveState_Locked);

   430 			test(KErrNone == gMgr->Disconnect(0));

   431 			test(KErrNone == gMgr->Disconnect(0)); // ensure it can be called more than once

   432 			NEXT(EStepDisconnecting);

   433 			break;

   435 		case EStepDisconnecting:

   436 			test(status==EUsbMsDriveState_Disconnecting);

   438 			test(KErrNone == gMgr->DeregisterDrive(0));

   439 			NEXT(EStepDisconnected);

   440 			break;

   442 		case EStepDisconnected:

   443 			test(status==EUsbMsDriveState_Disconnected);

   445 			test(KErrNone == gMgr->Connect(0));

   446 			test(KErrNone == gMgr->Connect(0)); // ensure it can be called more than once

   447 			NEXT(EStepConnecting);

   448 			break;

   450 		case EStepConnecting:

   451 			test(status==EUsbMsDriveState_Connecting);

   452 			CActiveScheduler::Stop();

   453 			break;

   455 		default:

   456 			break;

   457 		}

   459 	RDebug::Print(_L("<< PropertyHandlers::DriveStatus"));

   460 	}

   462 LOCAL_C void doTestL()

   463 	{

   464 	test.Start(_L("MSDrive1"));

   466 	CActiveScheduler* sched = new(ELeave) CActiveScheduler;

   467 	CleanupStack::PushL(sched);

   468 	CActiveScheduler::Install(sched);

   470 	RArray<TInt> driveMap;

   471 	CleanupClosePushL(driveMap);

   472 	driveMap.AppendL(gDrive1);

   473 	driveMap.AppendL(gDrive2);

   475 	gMgr = CDriveManager::NewL(driveMap);

   476 	CleanupStack::PushL(gMgr);

   477 	TInt err = KErrGeneral;

   478 	CMassStorageDrive* drive1 = gMgr->Drive(0,err);

   479 	test(err == KErrNone);

   481 	///////////////////////////////////////////////////////////////////////////

   482 	test.Next(_L("Check initial state"));

   483 	test(CMassStorageDrive::EDisconnected==drive1->MountState());

   484 	test(CMassStorageDrive::EErrDisMounted==drive1->DriveState());

   485 	test(0==drive1->KBytesRead());

   486 	test(0==drive1->KBytesWritten());

   487 	test(EFalse==drive1->IsMediaChanged());

   489 	///////////////////////////////////////////////////////////////////////////

   490 	test.Next(_L("Ensure Read/Write/Caps don't work when disconnected"));

   492 	const TInt KNoBytes = 1000;

   493 	TBuf8<KNoBytes> buf;

   494 	TLocalDriveCapsV4 caps;

   495 	test(KErrDisconnected==drive1->Read(0,0,buf));

   496 	test(KErrDisconnected==drive1->Write(0,buf));

   497 	test(KErrDisconnected==drive1->Caps(caps));

   499 	///////////////////////////////////////////////////////////////////////////

   500 	test.Next(_L("Test EConnecting state"));

   502 	drive1->SetMountConnecting();

   503 	test(CMassStorageDrive::EConnecting==drive1->MountState());

   504 	test(KErrDisconnected==drive1->Read(0,0,buf));

   505 	test(KErrDisconnected==drive1->Write(0,buf));

   506 	test(KErrDisconnected==drive1->Caps(caps));

   508 	///////////////////////////////////////////////////////////////////////////

   509 	test.Next(_L("Test EDisconnecting state"));

   511 	drive1->SetMountDisconnecting();

   512 	test(CMassStorageDrive::EDisconnecting==drive1->MountState());

   513 	test(KErrDisconnected==drive1->Read(0,0,buf));

   514 	test(KErrDisconnected==drive1->Write(0,buf));

   515 	test(KErrDisconnected==drive1->Caps(caps));

   517 	///////////////////////////////////////////////////////////////////////////

   518 	test.Next(_L("Test EConnected state"));

   520 	CTestProxyDrive* proxyDrive = new(ELeave) CTestProxyDrive(*gMgr);

   521 	CleanupStack::PushL(proxyDrive);

   523 	TBool mediaChanged = EFalse;

   524 	test(KErrNone==gMgr->RegisterDrive(*proxyDrive, mediaChanged, 0));

   525 	test(CMassStorageDrive::EConnected==drive1->MountState());

   527 	///////////////////////////////////////////////////////////////////////////

   528 	test.Next(_L("Test SetCritical"));

   529 	test(CMassStorageDrive::EIdle==drive1->DriveState());

   530 	test(KErrNone==drive1->SetCritical(ETrue));

   531 	test(CMassStorageDrive::EActive==drive1->DriveState());

   532 	test(KErrNone==drive1->SetCritical(EFalse));

   533 	test(CMassStorageDrive::EIdle==drive1->DriveState());

   535 	///////////////////////////////////////////////////////////////////////////

   536 	test.Next(_L("Test that ProxyDrive is called"));

   538 	CTestProxyDrive::iRetval = KErrNone;

   540 	// Test that bytesRead is incremented correctly

   541 	// when the count increments from 999 to 1000:

   542 	test(KErrNone==drive1->Read(0,999,buf));

   543 	test(0==drive1->KBytesRead());

   544 	test(KErrNone==drive1->Read(0,1,buf));

   545 	test(1==drive1->KBytesRead());

   547 	buf.SetLength(KNoBytes);

   548 	test(KErrNone==drive1->Write(0,buf));

   549 	test(KErrNone==drive1->Caps(caps));

   550 	// Write was called when EIdle, should restore state to EIdle

   551 	// after transient EActive state.

   552 	test(CMassStorageDrive::EIdle==drive1->DriveState());

   554 	CTestProxyDrive::iRetval = KErrDied;  // arbitrary test value

   555 	CTestProxyDrive::iRetval_caps = KErrDied;

   556 	test(KErrDied==drive1->Read(0,0,buf));

   557 	test(KErrDied==drive1->Write(0,buf));

   558 	test(KErrDied==drive1->Caps(caps));

   559 	CTestProxyDrive::iRetval = KErrNone;

   560 	CTestProxyDrive::iRetval_caps = KErrNone;

   562 	test.Next(_L("Test IsMediaChanged"));

   563 	test(EFalse==drive1->IsMediaChanged(ETrue));

   564 	test(EFalse==drive1->IsMediaChanged(EFalse));

   566 	///////////////////////////////////////////////////////////////////////////

   568 	CPropertyWatch::NewLC(EUsbMsDriveState_KBytesRead, PropertyHandlers::Read);

   569 	CPropertyWatch::NewLC(EUsbMsDriveState_KBytesWritten, PropertyHandlers::Written);

   570 	CPropertyWatch::NewLC(EUsbMsDriveState_DriveStatus, PropertyHandlers::DriveStatus);

   572 	///////////////////////////////////////////////////////////////////////////

   574 	NEXT(EStepRead0);

   575 	CActiveScheduler::Start();

   577 	///////////////////////////////////////////////////////////////////////////

   579 	test.Printf(_L("\nCLEANING UP\n"));

   581 	CleanupStack::PopAndDestroy(3); //CPropertyWatch x 3

   582 	CleanupStack::PopAndDestroy(proxyDrive);

   583 	CleanupStack::PopAndDestroy(gMgr);

   584 	CleanupStack::PopAndDestroy(&driveMap);

   585 	CleanupStack::PopAndDestroy(sched);

   587 	return;

   588 	}

   590 GLDEF_C TInt E32Main()

   591 	{

   592 	__UHEAP_MARK;

   593 	CTrapCleanup* cleanup=CTrapCleanup::New();

   595 	TRAPD(error,doTestL());

   596 	if (error)

   597 		test.Printf(_L("Leave occurred; code=%d\n"), error);

   599 	test.End();	// output success/fail

   600 	test.Close();

   602 	delete cleanup;

   603 	__UHEAP_MARKEND;

   604 	return 0;

   605 	}

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--