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