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

 // Soak tests reading from files

 // 

 //

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32test.h>

 #include <f32file.h>

 #include "utl.h"

 #include "randgen.h"

 GLREF_D RFs TheFs;

 GLDEF_D TInt gDriveNum;

 RTest	test( _L("T_ROFSSOAK") );

 _LIT( KTestFile1, "ReadTest\\A\\file1" );

 _LIT( KTestFile2, "ReadTest\\A\\file2" );

 _LIT( KTestFile3, "ReadTest\\B\\B3\\testfile" );

 _LIT( KTestFile4, "ReadTest\\B\\B4\\testfile" );

 _LIT( KTestFile5, "ReadTest\\D\\eoftest4" );

 _LIT( KTestFile6, "ReadTest\\D\\eoftest5" );

 _LIT( KTestFile7, "ReadTest\\E\\stream3" );

 _LIT( KTestFile8, "ReadTest\\E\\stream4" );

 _LIT( KTestFile9, "ReadTest\\C\\seektest" );

 _LIT( KTestFile10, "ReadTest\\D\\eoftest1" );

 _LIT( KTestFile11, "ReadTest\\D\\eoftest2" );

 _LIT( KTestFile12, "ReadTest\\D\\eoftest3" );

 _LIT( KTestFile13, "ReadTest\\A\\file3" );

 _LIT( KTestFile14, "ReadTest\\A\\file4" );

 _LIT( KTestFile15, "ReadTest\\B\\B2\\testfile" );

 _LIT( KTestFile16, "ReadTest\\E\\stream2" );

 const TInt KTestFileCount = 16;

 struct TestFiles

 	{

 	const TDesC*	iName;

 	TInt			iLength;

 	TUint			iSeed;

 	};

 const TestFiles TheFileArray[KTestFileCount] =

 	{

 		{ &KTestFile1, 256, 0xEF1113BC},

 		{ &KTestFile2, 256, 0x04082195},

 		{ &KTestFile3, 800, 0x42D4BF02},

 		{ &KTestFile4, 304, 0x47C728FB},

 		{ &KTestFile5, 30, 0x0CAAF228},

 		{ &KTestFile6, 7000, 0x1128A9A5},

 		{ &KTestFile7, 2000, 0x8DA9AA5A},

 		{ &KTestFile8, 17466, 0x8DA9AA5A},

 		{ &KTestFile9, 17466, 0x8DA9AA5A},

 		{ &KTestFile10, 3, 0x8DA9AA5A},

 		{ &KTestFile11, 7, 0x8DA9AA5A},

 		{ &KTestFile12, 64, 0x8DA9AA5A},

 		{ &KTestFile13, 256, 0xEC36D359},

 		{ &KTestFile14, 256, 0x07D4DAC2},

 		{ &KTestFile15, 500, 0x735AA240}, 

 		{ &KTestFile16, 5000, 0x8DA9AA5A}

 	};

 _LIT( KDriveBase, " :\\" );

 LOCAL_C void FillRandomBuffer( TDes8& aDes, TRandomGenerator& aRand, TInt aLength )

 	{

 	aDes.SetLength( aLength );

 	TUint* ptr = (TUint*)aDes.Ptr();

 	while( aLength >= 4 )

 		{

 		TUint v = aRand.Next();

 		*ptr++ = v;

 		aLength -= 4;

 		}

 	if( aLength )

 		{

 		TUint v = aRand.Next();

 		TUint8* p8 = (TUint8*)ptr;

 		while( aLength )

 			{

 			*p8++ = (TUint8)(v & 0xFF);

 			v >>= 8;

 			--aLength;

 			}

 		}

 	}

 LOCAL_C void Die()

 	{

 	_LIT( KCat, "Fail" );

 	RProcess().Panic( KCat, 0 );

 	//RProcess().Terminate(0);

 	}

 LOCAL_C void DoTestFile( TInt aFileIndex, TInt aThreadNumber )

 	{

 	RFile	file;

 	TRandomGenerator	rand;

 	TFileName name(KDriveBase);

 	name[0] = TText('A' + gDriveNum);

 	name.Append( *TheFileArray[aFileIndex].iName );

 	_LIT( KOpeningMessage, "Thread %d opening file %S" );

 	RDebug::Print( KOpeningMessage, aThreadNumber, &name );

 	TInt r = file.Open( TheFs, name, EFileRead | EFileShareReadersOnly );

 	if( KErrNone != r )

 		{

 		_LIT( KOpenFailMessage, "Thread %d open failed (%d)" );

 		RDebug::Print( KOpenFailMessage, aThreadNumber, r );

 		Die();

 		}

 	TInt fileLength;

 	r = file.Size( fileLength );

 	if( KErrNone != r )

 		{

 		_LIT( KSizeFailMessage, "Thread %d open failed (%d)" );

 		RDebug::Print( KSizeFailMessage, aThreadNumber, r );

 		Die();

 		}

 	if( fileLength != TheFileArray[aFileIndex].iLength )

 		{

 		_LIT( KLengthFailMessage, "Thread %d file length mismatch (%d %d)" );

 		RDebug::Print( KLengthFailMessage, aThreadNumber, fileLength, TheFileArray[aFileIndex].iLength );

 		Die();

 		}

 	const TInt KReadLen = 16;

 	TBuf8<KReadLen> readBuf;

 	TBuf8<KReadLen> randomBuf;

 	rand.SetSeed( TheFileArray[aFileIndex].iSeed );

 	TInt fragmentCount = (fileLength + KReadLen - 1) / KReadLen;

 	TInt lengthRemaining = fileLength;

 	for( TInt fragment = 0; fragment < fragmentCount; ++fragment )

 		{

 		TInt readLen = Min( KReadLen, lengthRemaining );

 		// read next fragment from each file and compare

 		FillRandomBuffer( randomBuf, rand, readLen );

 		r = file.Read( readBuf );

 		if( KErrNone != r )

 			{

 			_LIT( KReadFailMessage, "Thread %d read failed (%d)" );

 			RDebug::Print( KReadFailMessage, aThreadNumber, r );

 			Die();

 			}

 		if( readLen != readBuf.Length() )

 			{

 			_LIT( KReadLenFailMessage, "Thread %d read length mismatch (%d %d)" );

 			RDebug::Print( KReadLenFailMessage, aThreadNumber, readLen, readBuf.Length() );

 			Die();

 			}

 		if( readBuf != randomBuf )

 			{

 			_LIT( KCmpFailMessage, "Thread %d read data mismatch" );

 			RDebug::Print( KCmpFailMessage, aThreadNumber );

 			Die();

 			}

 		lengthRemaining -= readLen;

 		}

 	file.Close();

 	}

 LOCAL_C TInt SoakThread( TAny* aParam )

 	//

 	// Runs through the list of files opening and reading them

 	// comparing against the random number generator

 	//

 	// aParam is the index in TheFileArray of the first file to test

 	// and is also the thread number

 	//

 	{

 	const TInt threadNumber = (TInt)aParam;

 	TInt nextFileIndex = (3 * threadNumber) % KTestFileCount;

 	TRandomGenerator randTime;

 	randTime.SetSeed( 0xA4BB926A * nextFileIndex );

 	for(;;)

 		{

 		DoTestFile( nextFileIndex, threadNumber );

 		User::After( randTime.Next() % 250000 );

 		nextFileIndex = (nextFileIndex + 1) % KTestFileCount;

 		}

 	}

 //************************

 // Entry point

 void DoTestL(TInt aDriveToTest)

 	{

 	test.Title();

 	test.Start( _L("Testing ROFS file reading") );

 	gDriveNum = aDriveToTest;

 	// Share file server session between all threads

 	TheFs.ShareAuto();

 	RThread thread1;

 	RThread thread2;

 	RThread thread3;

 	RThread thread4;

 	thread1.Create( _L("ROFSSOAK1"), SoakThread, 4096, 4096, 65536, (TAny*)0 );

 	thread2.Create( _L("ROFSSOAK2"), SoakThread, 4096, 4096, 65536, (TAny*)1 );

 	thread3.Create( _L("ROFSSOAK3"), SoakThread, 4096, 4096, 65536, (TAny*)2 );

 	thread4.Create( _L("ROFSSOAK4"), SoakThread, 4096, 4096, 65536, (TAny*)3 );

 	thread1.Resume();

 	thread2.Resume();

 	thread3.Resume();

 	thread4.Resume();

 	RThread().Suspend();

 	}