// 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();

	}