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

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

RTest	test( _L("T_ROFSFILE") );

_LIT( KSpotFile1, "root.txt" );

_LIT( KSpotFile2, "Dir1\\level1.txt" );

_LIT( KSpotFile3, "Dir1\\Dir2\\level2.txt" );

_LIT( KSpotFile4, "Dir1\\Dir2\\Dir3\\level3.txt" );

_LIT( KSpotFile5, "Dir1\\Dir2\\Dir3\\Dir4\\level4.txt" );

_LIT( KSpotFile6, "Dir1\\Dir2\\Dir3\\Dir4\\Dir5\\level5.txt" );

_LIT( KSpotFile7, "Dir1\\Dir2\\Dir3\\Dir4\\Dir5\\Dir6\\level6.txt" );

_LIT( KSpotFile8, "Dir1\\Dir2\\Dir3\\Dir4\\Dir5\\Dir6\\Dir7\\level7.txt" );

_LIT( KSpotFile9, "DeepDir1\\DeepDir2\\DeepDir3\\DeepDir4\\DeepDir5\\DeepDir6\\DeepDir7\\DeepDir8\\DeepDir9\\DeepDir10\\DeepDir11\\DeepDir12\\DeepDir13\\DeepDir14\\file.txt" );

_LIT( KSpotFile10, "Parent\\parfile.txt" );

_LIT( KSpotFile11, "Parent\\SubDir1A\\subfileA.txt" );

_LIT( KSpotFile12, "Mixed\\par1.txt" );

_LIT( KSpotFile13, "Mixed\\SubDir1\\sub1.txt" );

_LIT( KSpotFile14, "Mixed\\SubDir2\\sub2.txt" );

_LIT( KSpotFile15, "Dir1\\level1_ext.txt" );

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

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

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

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

const TInt KSameDirFileLength = 256;

const TUint KSameDirFile1Seed = 0xEF1113BC;

const TUint KSameDirFile2Seed = 0x04082195;

const TUint KSameDirFile3Seed = 0xEC36D359;

const TUint KSameDirFile4Seed = 0x07D4DAC2;

_LIT( KSameNameFile1, "ReadTest\\B\\B1\\testfile" );

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

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

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

const TInt KSameNameFileLength = 256;	// we will read this much of the file

const TUint KSameNameFile1Seed = 0x8DA9AA5A;

const TUint KSameNameFile2Seed = 0x735AA240;

const TUint KSameNameFile3Seed = 0x42D4BF02;

const TUint KSameNameFile4Seed = 0x47C728FB;

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

const TInt KRandomReadFileSize = 17466;

const TUint KRandomReadFileSeed = 0x8DA9AA5A;

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

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

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

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

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

_LIT( KEofFile6, "ReadTest\\D\\eoftest6" );

_LIT( KStreamFile1, "ReadTest\\E\\stream1" );

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

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

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

_LIT( KTestFileExt, "ext.txt" );

const TUint KStreamReadSeed = 0x8DA9AA5A;

_LIT( KDriveBase, " :\\" );

const TInt KHello8FileSize = 5;

_LIT8( KHello8FileContent, "hello" );

// A large buffer for file reads

LOCAL_D TBuf8<18000> gFileBuffer;

LOCAL_C void SpotCheckFilesL(TInt aDriveToTest, TBool aExtension)

//

// Tests a few files for size & content. These are all the hello8.txt test file

//

	{

	const TDesC* const fileArray[15] =

		{

		&KSpotFile1, &KSpotFile2, &KSpotFile3, &KSpotFile4, &KSpotFile5,

		&KSpotFile6, &KSpotFile7, &KSpotFile8, &KSpotFile9, &KSpotFile10,

		&KSpotFile11, &KSpotFile12, &KSpotFile13, &KSpotFile14, &KSpotFile15

		};

	test.Next( _L("Spot-check some files") );

	TFileName name(KDriveBase);

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

	TInt index =0;

	if(aExtension) index =1;

	for( TInt i = index; i < 14; i++ )

		{

		name.SetLength( 3 );	// trim back to drive specifier

		if(aExtension &&(i==1))

			name.Append( *fileArray[i+13] );

		else

			name.Append( *fileArray[i] );

		test.Printf( _L("Opening file %S"), &name );

		RFile file;

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

		TEST_FOR_ERROR( r );

		TInt fileSize;

		r = file.Size( fileSize );

		TEST_FOR_ERROR( r );

		TEST_FOR_MATCH( fileSize, KHello8FileSize );

		TBuf8<5> buf;

		r = file.Read( buf );

		TEST_FOR_ERROR( r );

		TEST_FOR_MATCH( buf.Length(), KHello8FileSize );

		test(buf == KHello8FileContent);

		file.Close();

		}

	}

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 TBool ValidateRandomBuffer( const TDes8& aDes, TUint aSeed )

	{

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

	TInt length = aDes.Length();

	TRandomGenerator rand;

	rand.SetSeed( aSeed );

	while( length >= 4 )

		{

		TUint v = rand.Next();

		if( *ptr++ != v )

			{

			return EFalse;

			}

		length -= 4;

		}

	if( length )

		{

		TUint v = rand.Next();

		TUint8* p8 = (TUint8*)ptr;

		while( length )

			{

			if( *p8++ != (TUint8)(v & 0xFF) )

				{

				return EFalse;

				}

			v >>= 8;

			--length;

			}

		}

	return ETrue;

	}

LOCAL_C void TestFilesInSameDirectoryL(TInt aDriveToTest)

	//

	// Tests opening different files in the same directory

	//

	{

	test.Next( _L("Testing files in same directory") );

	struct TTheFiles

		{

		RFile	iFile;

		TRandomGenerator	iRand;

		};

	TTheFiles files[4];

	TFileName name(KDriveBase);

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

	name.Append( KSameDirFile1 );

	TInt r = files[0].iFile.Open( TheFs, name, EFileRead );

	TEST_FOR_ERROR( r );

	name.SetLength( 3 );

	name.Append( KSameDirFile2 );

	r = files[1].iFile.Open( TheFs, name, EFileRead );

	TEST_FOR_ERROR( r );

	name.SetLength( 3 );

	name.Append( KSameDirFile3 );

	r = files[2].iFile.Open( TheFs, name, EFileRead );

	TEST_FOR_ERROR( r );

	name.SetLength( 3 );

	name.Append( KSameDirFile4 );

	r = files[3].iFile.Open( TheFs, name, EFileRead );

	TEST_FOR_ERROR( r );

	const TInt KReadLen = KSameDirFileLength / 16;

	TBuf8<KReadLen> readBuf;

	TBuf8<KReadLen> randomBuf;

	files[0].iRand.SetSeed( KSameDirFile1Seed );

	files[1].iRand.SetSeed( KSameDirFile2Seed );

	files[2].iRand.SetSeed( KSameDirFile3Seed );

	files[3].iRand.SetSeed( KSameDirFile4Seed );

	for( TInt fragment = 0; fragment < (KSameDirFileLength / KReadLen); ++fragment )

		{

		// read next fragment from each file and compare

		for( TInt j = 0; j < 4; ++j )

			{

			FillRandomBuffer( randomBuf, files[j].iRand, KReadLen );

			r = files[j].iFile.Read( readBuf );

			TEST_FOR_ERROR( r );

			TEST_FOR_MATCH( readBuf.Length(), KReadLen );

			test( readBuf == randomBuf );

			}

		}

	files[0].iFile.Close();

	files[1].iFile.Close();

	files[2].iFile.Close();

	files[3].iFile.Close();

	}

LOCAL_C void TestFilesSameNameDifferentDirectoryL(TInt aDriveToTest)

	//

	// Tests opening files with the same name but in different directories

	//

	{

	test.Next( _L("Testing files with same name in different directories") );

	struct TTheFiles

		{

		RFile	iFile;

		TRandomGenerator	iRand;

		};

	TTheFiles files[4];

	TFileName name(KDriveBase);

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

	name.Append( KSameNameFile1 );

	TInt r = files[0].iFile.Open( TheFs, name, EFileRead );

	TEST_FOR_ERROR( r );

	name.SetLength( 3 );

	name.Append( KSameNameFile2 );

	r = files[1].iFile.Open( TheFs, name, EFileRead );

	TEST_FOR_ERROR( r );

	name.SetLength( 3 );

	name.Append( KSameNameFile3 );

	r = files[2].iFile.Open( TheFs, name, EFileRead );

	TEST_FOR_ERROR( r );

	name.SetLength( 3 );

	name.Append( KSameNameFile4 );

	r = files[3].iFile.Open( TheFs, name, EFileRead );

	TEST_FOR_ERROR( r );

	const TInt KReadLen = KSameNameFileLength / 16;

	TBuf8<KReadLen> readBuf;

	TBuf8<KReadLen> randomBuf;

	files[0].iRand.SetSeed( KSameNameFile1Seed );

	files[1].iRand.SetSeed( KSameNameFile2Seed );

	files[2].iRand.SetSeed( KSameNameFile3Seed );

	files[3].iRand.SetSeed( KSameNameFile4Seed );

	for( TInt fragment = 0; fragment < (KSameDirFileLength / KReadLen); ++fragment )

		{

		// read next fragment from each file and compare

		for( TInt j = 0; j < 4; ++j )

			{

			FillRandomBuffer( randomBuf, files[j].iRand, KReadLen );

			r = files[j].iFile.Read( readBuf );

			TEST_FOR_ERROR( r );

			TEST_FOR_MATCH( readBuf.Length(), KReadLen );

			test( readBuf == randomBuf );

			}

		}

	files[0].iFile.Close();

	files[1].iFile.Close();

	files[2].iFile.Close();

	files[3].iFile.Close();

	}

LOCAL_C void TestRandomSeekL(TInt aDriveToTest)

	//

	// Tests reading from random positions in a file

	//

	{

	test.Next( _L("Testing random read position") );

	TFileName name(KDriveBase);

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

	name.Append( KRandomReadFile );

	RFile file;

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

	TEST_FOR_ERROR( r );

	// Check file size

	TInt fileSize;

	r = file.Size( fileSize ), 

	TEST_FOR_ERROR( r );

	TEST_FOR_MATCH( fileSize, KRandomReadFileSize );

	// Fill buffer with expected file contents

	TRandomGenerator rand;

	rand.SetSeed( KRandomReadFileSeed );

	FillRandomBuffer( gFileBuffer, rand, KRandomReadFileSize );

	// Read from random positions within the file

	rand.SetSeed( 0xA6E320F1 );

	const TInt KMaxRead = 256;

	TBuf8<KMaxRead> buf;

	const TInt maxRead = Min( fileSize, buf.MaxLength() );

	for( TInt readCount = 0; readCount < 100; ++readCount )

		{

		TInt readLen = rand.Next() % (maxRead+1);

		if( readLen > buf.MaxLength() )

			{

			readLen = buf.MaxLength();

			}

		TInt readPos = rand.Next() % (fileSize - readLen);

		_LIT( KMessage, "Reading %d bytes from 0x%x" );

		test.Printf( KMessage, readLen, readPos );

		const TUint8* pExpected = gFileBuffer.Ptr() + readPos;

		r = file.Seek( ESeekStart, readPos );

		TEST_FOR_ERROR( r );

		r = file.Read( buf, readLen );

		TEST_FOR_ERROR( r );

		TEST_FOR_MATCH( buf.Length(), readLen );

		const TUint8* pRead = buf.Ptr();

		test( 0 == Mem::Compare( pExpected, readLen, pRead, readLen ) );

		}

	}

LOCAL_C void TestEofReadL(TInt aDriveToTest)

	//

	// Test reading off the end of a file

	//

	{

	test.Next( _L("Testing reading past EOF") );

	const TDesC* const fileArray[6] =

		{

		&KEofFile1, &KEofFile2, &KEofFile3, &KEofFile4, &KEofFile5, &KEofFile6

		};

	TFileName name(KDriveBase);

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

	TRandomGenerator rand;

	rand.SetSeed( 0x1001A005 );

	for( TInt i = 0; i < 6; i++ )

		{

		name.SetLength( 3 );	// trim back to drive specifier

		name.Append( *fileArray[i] );

		test.Printf( _L("Opening file %S"), &name );

		RFile file;

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

		TEST_FOR_ERROR( r );

		TInt fileSize;

		r = file.Size( fileSize ), 

		TEST_FOR_ERROR( r );

		test( fileSize > 0 );

		TInt readPos = fileSize - ( rand.Next() % 12);

		if( readPos < 0 )

			{

			readPos = 0;

			}

		r = file.Seek( ESeekStart, readPos );

		TEST_FOR_ERROR( r );

		TBuf8<32> buf;

		r = file.Read( buf );

		TEST_FOR_ERROR( r );

		TEST_FOR_MATCH( buf.Length(), fileSize - readPos );

		file.Close();

		}

	}

LOCAL_C void TestStreamReadL(TInt aDriveToTest)

	//

	// Reads the whole file into a buffer in a single read

	// and validates the data

	//

	{

	test.Next( _L("Testing whole file read") );

	const TDesC* const fileArray[4] =

		{

		&KStreamFile1, &KStreamFile2, &KStreamFile3, &KStreamFile4

		};

	TFileName name(KDriveBase);

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

	for( TInt i = 0; i < 4; ++i )

		{

		name.SetLength(3);

		name.Append( *fileArray[i] );

		test.Printf( _L("... file %S"), &name );

		RFile file;

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

		TEST_FOR_ERROR( r );

		TInt fileSize;

		r = file.Size( fileSize ), 

		TEST_FOR_ERROR( r );

		test( fileSize > 0 );

		r = file.Read( gFileBuffer );

		TEST_FOR_ERROR( r );

		TEST_FOR_MATCH( fileSize, gFileBuffer.Length() );

		test( ValidateRandomBuffer( gFileBuffer, KStreamReadSeed ) );

		file.Close();

		}

	}

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

// Entry point

void DoTestL(TInt aDriveToTest)

	{

	test.Title();

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

	test.Printf( _L("Looking for ROFS extension\n"));

	TBool extension = EFalse;

	TFileName name(KDriveBase);

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

	name.SetLength( 3 );	// trim back to drive specifier

	name.Append( KTestFileExt );

	RFile file;

	test.Printf( _L("Opening file %S"), &name );

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

	if(r==KErrNone)

		{

		extension=ETrue;

		file.Close();

		test.Printf( _L("ROFS extension found\n"));

		}

	else if(r==KErrNotFound)

		{

		test.Printf( _L("Not found, ROFS extension not present\n"));

		}

	SpotCheckFilesL(aDriveToTest, extension);

	TestFilesInSameDirectoryL(aDriveToTest);

	TestFilesSameNameDifferentDirectoryL(aDriveToTest);

	TestRandomSeekL(aDriveToTest);

	TestEofReadL(aDriveToTest);

	TestStreamReadL(aDriveToTest);

	test.End();

	}