// Copyright (c) 1995-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:

// f32test\server\t_dirs.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include "t_server.h"

#include "f32_test_utils.h"

using namespace F32_Test_Utils;

RTest test(_L("T_DIRS"));

TTime gTimeNow;

TBool gTestedZ = EFalse;

TInt gDriveNum = -1;

static void Test1()

//

// Make a directory with lots of entries

//

	{

	RFile f;

	TInt maxEntry=56;

	test.Next(_L("Create a directory with 55 entries"));

	TFileName sessionPath;

	TInt r=TheFs.SessionPath(sessionPath);

	test_KErrNone(r);

	r=TheFs.MkDir(_L("\\F32-TST\\"));

	test_Value(r, (r == KErrNone)||(r==KErrAlreadyExists));

	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\"));

	test_Value(r, (r == KErrNone)||(r==KErrAlreadyExists));

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

		{

		TFileName baseName=_L("\\F32-TST\\TDIRS\\FILE");

		baseName.AppendNum(i);

		r=f.Replace(TheFs,baseName,EFileRead);

		test_KErrNone(r);

		r=f.Write(_L8("Hello World"));

		test_KErrNone(r);

		f.Close();

		}

	test.Next(_L("Test all entries have been created successfully."));

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

		{

		TFileName baseName=_L("\\F32-TST\\TDIRS\\FILE");

		baseName.AppendNum(j);

		TInt r=f.Open(TheFs,baseName,EFileRead);

		if (r!=KErrNone)

			{

			test_Value(r, r == KErrNotFound && j==maxEntry);

			return;

			}

		TBuf8<16> data;

		r=f.Read(data);

		test_KErrNone(r);

		test(data==_L8("Hello World"));

		f.Close();

		}

	}

static void Test2()

//

// List all directory entries

//

	{

	test.Printf(_L("List all entries in directory %S\n"),&gSessionPath);

	RDir d;

	TInt r=d.Open(TheFs,gSessionPath,KEntryAttMaskSupported);

	if (r==KErrNone)

		{

		TEntry e;

		while ((r=d.Read(e))==KErrNone)

			{

			if (e.IsDir())

				test.Printf(_L("%- 20S <DIR>\n"),&e.iName);

			else

				test.Printf(_L("%- 20S %+ 8d\n"),&e.iName,e.iSize);

			}

		d.Close();

		if (r!=KErrEof)

			test.Printf(_L("Error %d\n"),r);

		}

	else

		test.Printf(_L("Error %d\n"),r);	

	}

static void TestZ()

//

// Check you cannot open a directory on a file

//

	{

	test.Next(_L("Open files and directories on Z:"));

	TEntry entry;

	RDir d;

	TInt r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\ESHELL.EXE\\*"):_L("\\System\\Bin\\ESHELL.EXE\\*"),KEntryAttMaskSupported);

	test_Value(r, r == KErrPathNotFound);

	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\ESHELL.EXE"):_L("\\System\\Bin\\ESHELL.EXE"),KEntryAttMaskSupported);

	test_KErrNone(r);

	r=d.Read(entry);

	if (r==KErrEof)

		{

		test.Printf(_L("Error: EShell.EXE not found\n"));

		//test.Getch();

		}

	else

		{

		test_KErrNone(r);

		test(entry.iName.FindF(_L("ESHELL.EXE"))>=0);

		r=d.Read(entry);

		test_Value(r, r == KErrEof);

		}

	d.Close();

	r=d.Open(TheFs,_L("\\*.XQP"),KEntryAttMaskSupported);

	test_KErrNone(r);

	r=d.Read(entry);

	test_Value(r, r == KErrEof);

	d.Close();

	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\"):_L("\\System\\Bin\\"),KEntryAttMaskSupported);

	test_KErrNone(r);

	r=d.Read(entry);

	if (r==KErrEof)

		{

		test.Printf(_L("No files found\n"));

		d.Close();

		}

	else

		{

		test_KErrNone(r);

		test.Printf(_L("First Entry = %S\n"),&entry.iName);

		r=d.Read(entry);

		test_KErrNone(r);

		test.Printf(_L("Second Entry = %S\n"),&entry.iName);

		d.Close();

		}

	r=d.Open(TheFs,_L("\\*"),KEntryAttMaskSupported);

	test_KErrNone(r);

	d.Close();

	r=d.Open(TheFs,PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("\\Sys\\Bin\\*"):_L("\\System\\Bin\\*"),KEntryAttMaskSupported);

	test_KErrNone(r);

	d.Close();

	}

static void Test3()

//

// Check you cannot open a directory on a file

//

	{

	test.Next(_L("Open files and directories"));

	TEntry entry;

	RFile f;

	TInt r=f.Replace(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"),EFileWrite);

	test_KErrNone(r);

	r=f.Write(_L8("TESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATATESTDATA"));

	test_KErrNone(r);

	r=TheFs.Delete(_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"));

	test_Value(r, r == KErrInUse);

	f.Close();

	RDir d;

	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR\\*"),KEntryAttMaskSupported);

	test_Value(r, r == KErrPathNotFound);

	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\*.XQP"),KEntryAttMaskSupported);

	test_KErrNone(r);

	r=d.Read(entry);

	test_Value(r, r == KErrEof);

	d.Close();

	r=d.Open(TheFs,_L("\\F32-TST\\TDIRS\\TESTFILEORISITA.DIR"),KEntryAttMaskSupported);

	test_KErrNone(r);

	r=d.Read(entry);

	test_KErrNone(r);

	test(entry.iName.FindF(_L("TESTFILEORISITA.DIR"))>=0);

	r=d.Read(entry);

	test_Value(r, r == KErrEof);

	d.Close();

	r=d.Open(TheFs,_L("\\"),KEntryAttMaskSupported);

	test_KErrNone(r);

	d.Close();

	r=d.Open(TheFs,_L("\\F32-TST\\"),KEntryAttMaskSupported);

	test_KErrNone(r);

	d.Close();

	r=d.Open(TheFs,_L("\\*"),KEntryAttMaskSupported);

	test_KErrNone(r);

	d.Close();

	r=d.Open(TheFs,_L("\\F32-TST\\*"),KEntryAttMaskSupported);

	test_KErrNone(r);

	d.Close();

	// create a small file on the root

	test(f.Replace(TheFs, _L("\\TEST.FILE"), EFileWrite) == KErrNone);

	test(f.Write(_L8("1234567890987654321234567890")) == KErrNone);

	f.Close();

	// try some directory operations on the file

	test(TheFs.RmDir(_L("\\TEST.FILE\\")) == KErrPathNotFound);

	test(TheFs.RmDir(_L("\\TEST.FILE\\ZZZ\\")) == KErrPathNotFound);

	test(TheFs.MkDir(_L("\\TEST.FILE\\ZZZ\\")) == KErrPathNotFound);

	// cleanup

	TheFs.Delete(_L("\\TEST.FILE"));	

	r=TheFs.MkDir(_L("\\F32-TST\\EMPTY\\"));

	test_Value(r, r == KErrNone || r==KErrAlreadyExists);

	r=d.Open(TheFs,_L("\\F32-TST\\EMPTY\\*"),KEntryAttMaskSupported);

	test_KErrNone(r);

//	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));

	r=d.Read(entry);

	test_Value(r, r == KErrEof);

//	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));

//	test_Value(r, r == KErrInUse);

	r=d.Read(entry);

	r=d.Read(entry);

	r=d.Read(entry);

	d.Close();

	r=TheFs.RmDir(_L("\\F32-TST\\EMPTY\\"));

	test_KErrNone(r);

	}

static void CreateSortNoneTestDirectoryStructure()

//

// Create files

//

	{

//	Delete the directory to be tested if it already exists as a result of this

//	test being run previously.  It's necessary remove it and then recreate it 

//	because a later test relies on the time of file/directory creation to be

//	the time this function was run...

	CFileMan* fMan=CFileMan::NewL(TheFs);

	test(fMan!=NULL);

	TInt r=fMan->RmDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\"));

	test_Value(r, (r == KErrNone)||(r==KErrPathNotFound));

	delete fMan;	

	gTimeNow.HomeTime();	//	Set global TTime gTimeNow to time now - for later tests

	r=TheFs.MkDirAll(_L("\\F32-TST\\TDIRS\\SORT_NONE\\"));

	test_Value(r, r == KErrNone || r==KErrAlreadyExists);

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file1.txt"));

	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR1.APP\\"));

	test_Value(r, r == KErrNone || r==KErrAlreadyExists);

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file1.app"));

	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR2.TXT\\"));

	test_Value(r, r == KErrNone || r==KErrAlreadyExists);

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file2.txt"));

	r=TheFs.MkDir(_L("\\F32-TST\\TDIRS\\SORT_NONE\\FILE_DIR3.APP\\"));

	test_Value(r, r == KErrNone || r==KErrAlreadyExists);

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\ZZZZ"));

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\AAAA"));

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\WWWW"));

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file2.app"));

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file3.txt"));

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\file3.app"));

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\NOEXT1"));

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\NOEXT2"));

	MakeFile(_L("\\f32-tst\\tdirs\\sort_none\\EXTMISSING"));

	}

static void Test4()

//

// Test ESortNone

//

	{

	test.Next(_L("Test ESortNone"));

	CreateSortNoneTestDirectoryStructure();

	CDir* dir;

	CDir* dirSorted;

//

// GetDir OOM failure passes 'callback' test from client side but not server side

//

	TheFs.SetAllocFailure(gAllocFailOff);

	TInt r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*"),KEntryAttMaskSupported,ESortNone,dir);

	test_KErrNone(r);

	TInt count=dir->Count();

	test(count==15);

	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*"),KEntryAttMaskSupported,ESortByName,dirSorted);

	test_KErrNone(r);

	test(dirSorted->Count()==15);

	delete dirSorted;

	delete dir;

	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.txt"),KEntryAttNormal,ESortNone,dir);

	test_KErrNone(r);

	test(dir->Count()==3);

	delete dir;

	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal,ESortNone,dir);

	test_KErrNone(r);

	test(dir->Count()==3);

	delete dir;

	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone,dir);

	test_KErrNone(r);

	test(dir->Count()==5);

	delete dir;

	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone|EDirsFirst,dir);

	test_KErrNone(r);

	test(dir->Count()==5);

	delete dir;

	r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.app"),KEntryAttNormal|KEntryAttDir,ESortNone|EDirsLast,dir);

	test_KErrNone(r);

	test(dir->Count()==5);

	delete dir;

	TheFs.SetAllocFailure(gAllocFailOn);

	}

static void Test5()

//

// Test return values

//

	{

	test.Next(_L("Test return values"));

	RDir dir;

	TInt r=dir.Open(TheFs,_L("\\DoesNotExist\\*"),KEntryAttMaskSupported);

	test_Value(r, r == KErrPathNotFound);

	r=dir.Open(TheFs,_L("\\"),KEntryAttMaskSupported);

	test_KErrNone(r);

	dir.Close();

	}

static void Test6()

//

// Test that "*.*" matches all files/directories

//

	{

	test.Next(_L("Test *.* matches all files"));

	CDir* dirList;

	TInt r=TheFs.GetDir(_L("\\f32-tst\\tdirs\\sort_none\\*.*"),KEntryAttNormal|KEntryAttDir,ESortByName|EDirsLast,dirList);

	test_KErrNone(r);

	TInt count=dirList->Count();

	test(count==15);

	TEntry entry=(*dirList)[0];

	test(entry.iName.FindF(_L("AAAA"))>=0);

	entry=(*dirList)[1];

	test(entry.iName.FindF(_L("EXTMISSING"))>=0);

	entry=(*dirList)[2];

	test(entry.iName.FindF(_L("FILE1.APP"))>=0);

	entry=(*dirList)[3];

	test(entry.iName.FindF(_L("FILE1.TXT"))>=0);

	entry=(*dirList)[4];

	test(entry.iName.FindF(_L("FILE2.APP"))>=0);

	entry=(*dirList)[5];

	test(entry.iName.FindF(_L("FILE2.TXT"))>=0);

	entry=(*dirList)[6];

	test(entry.iName.FindF(_L("FILE3.APP"))>=0);

	entry=(*dirList)[7];

	test(entry.iName.FindF(_L("FILE3.TXT"))>=0);

	entry=(*dirList)[8];

	test(entry.iName.FindF(_L("NOEXT1"))>=0);

	entry=(*dirList)[9];

	test(entry.iName.FindF(_L("NOEXT2"))>=0);

	entry=(*dirList)[10];

	test(entry.iName.FindF(_L("WWWW"))>=0);

	entry=(*dirList)[11];

	test(entry.iName.FindF(_L("ZZZZ"))>=0);

	entry=(*dirList)[12];

	test(entry.iName.FindF(_L("FILE_DIR1.APP"))>=0);

	entry=(*dirList)[13];

	test(entry.iName.FindF(_L("FILE_DIR2.TXT"))>=0);

	entry=(*dirList)[14];

	test(entry.iName.FindF(_L("FILE_DIR3.APP"))>=0);

	delete dirList;

	RDir dir;

	r=dir.Open(TheFs,_L("\\f32-tst\\tdirs\\sort_none\\*.*"),KEntryAttNormal|KEntryAttDir);

	test_KErrNone(r);

	TTime time;

	TInt64 difference;

	TInt64 maxOK=1000000;

	maxOK*=60;

	maxOK*=3;

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

		{

		r=dir.Read(entry);

		test_KErrNone(r);

		time=entry.iModified;

		difference=time.Int64()-gTimeNow.Int64();

		test(difference<maxOK);

		}

	r=dir.Read(entry);

	test_Value(r, r == KErrEof);

	dir.Close();

	TheFs.SetAllocFailure(gAllocFailOn);

	}

static void Test7()

//

// Fill up the root directory

//

	{

    test.Next(_L("Fill up the root directory"));

    if(!Is_Fat12(TheFs, gDriveNum) && !Is_Fat16(TheFs, gDriveNum))

        {

        test.Printf(_L("Skipping. Applicable for FAT12/16 only!\n"));

        return;

        }    

    TInt r = FormatDrive(TheFs, gDriveNum, ETrue);

    test_KErrNone(r);

	TBuf<32> baseName=_L("\\RD");

	TBuf<32> id;

	TBuf<32> fileName;

	TInt count=0;

	RFile f;

	TParsePtrC parser(gSessionPath);

	FOREVER

		{

		id.Num(count+1);

		fileName=parser.Drive();

		fileName+=baseName;

		fileName+=id;

		TInt r=f.Replace(TheFs,fileName,EFileWrite);

		if(r==KErrDirFull)

			{

			break;

			}

		test_KErrNone(r);

		f.Close();

		count++;

		if(count >= 1000)

			{

			break;

			}

		test.Printf(_L("CreateFile	:	%d	: %S\r"),count,&fileName);

		}

	test.Printf(_L("\n"));

	while (count)

		{

		id.Num(count);

		fileName=parser.Drive();

		fileName+=baseName;

		fileName+=id;

		TInt r=TheFs.Delete(fileName);

		test_KErrNone(r);

		test.Printf(_L("DeleteFile	:	%d	: %S\r"),count,&fileName);

		--count;

		}

	test.Printf(_L("\n"));

	test.Next(_L("Long filenames in root"));

	TFileName longFileName;

	longFileName.SetLength(254);

//	Mem::Fill((TUint8*)longFileName.Ptr(),254,'A');

	Mem::Fill((TUint8*)longFileName.Ptr(),254*sizeof(TText),'A');

	longFileName[0]='\\';

	longFileName[253]='\\';

	r=TheFs.MkDir(longFileName);

	test_KErrNone(r);

	CDir* dirList=NULL;

	r=TheFs.GetDir(longFileName,KEntryAttMaskSupported,ESortByName,dirList);

	test_KErrNone(r);

	count=dirList->Count();

	test(count==0);

	delete dirList;

	TParse parse;

	r=TheFs.Parse(longFileName,parse);

	test_KErrNone(r);

	TEntry entry;

	r=TheFs.Entry(longFileName,entry);

	test_KErrNone(r);

	r=TheFs.SetSessionPath(longFileName);

	test_KErrNone(r);

	r=TheFs.GetDir(longFileName,KEntryAttMaskSupported,ESortByName,dirList);

	test_KErrNone(r);

	count=dirList->Count();

	test(count==0);

	delete dirList;

	r=TheFs.Parse(longFileName,_L("*"),parse);

	test_Value(r, r == KErrBadName);

	r=f.Open(TheFs,_L("asdf.asdf"),0);

	test_Value(r, r == KErrBadName);

	r=TheFs.Entry(longFileName,entry);

	test_KErrNone(r);

	r=TheFs.RmDir(longFileName);