// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

#ifdef __TOOLS2__

#include <sys/stat.h>

#include <stdlib.h>

#ifdef linux

#include <string.h>

#endif

#endif

#include <e32test.h>

#include <f32file.h>

RTest test(_L("SymFile RFs Tests"));

void testAtt()

	{

	// Connect to the file system

	RFs fs;

	test(fs.Connect() == KErrNone);

	_LIT(KTestDir1, "c:\\symport_test_rfs1\\");

	_LIT(KTestFile, "c:\\symport_test_rfs1\\test.txt");

	// Test with root

	TUint att;

	test(fs.Att(_L("C:\\"), att) == KErrBadName);

	test(fs.Att(_L("\\"), att) == KErrBadName);

	// Make sure the directory doesn't exist

	TInt err = fs.Delete(KTestFile);

	test(err == KErrNone || err == KErrNotFound || err == KErrPathNotFound);

	err = fs.RmDir(KTestDir1);

	test(err == KErrNone || err == KErrNotFound);

	// Check it fails

	test(fs.Att(KTestDir1, att) == KErrNotFound);

	// See if it works for directories

	test(fs.MkDir(KTestDir1) == KErrNone);

	test(fs.Att(KTestDir1, att) == KErrNone && att&KEntryAttDir);

	// See if it works for normal files

	test(fs.Att(KTestFile, att) == KErrNotFound);

	RFile file;

	test(file.Create(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

	file.Close();

	test(fs.Att(KTestFile, att) == KErrNone);

	test(!(att&KEntryAttDir));

	// Check readonly flag

	test(!(att&KEntryAttReadOnly));

	test(fs.SetAtt(KTestFile, KEntryAttReadOnly, 0) == KErrNone);

	test(fs.Att(KTestFile, att) == KErrNone && att&KEntryAttReadOnly);

	// Clear the flag

	test(fs.SetAtt(KTestFile, 0, KEntryAttReadOnly) == KErrNone);

	test(fs.Att(KTestFile, att) == KErrNone);

	test(!(att&KEntryAttReadOnly));

	// Delete the file and make sure it goes away

	test(fs.RmDir(KTestDir1) == KErrInUse);

	test(fs.Delete(KTestFile) == KErrNone);

	test(fs.Att(KTestFile, att) == KErrNotFound);

	// Delete directory and make sure it really went away

	test(fs.RmDir(KTestDir1) == KErrNone);

	test(fs.Att(KTestDir1, att) == KErrNotFound);

	fs.Close();

	}

void testSetAtt()

	{

	// Connect to the file system

	RFs fs;

	test(fs.Connect() == KErrNone);

	// Make sure the file doesn't exist

	_LIT(KTestFile, "c:\\symport_test_rfs2_test.txt");

	fs.SetAtt(KTestFile, 0, KEntryAttReadOnly);

	fs.Delete(KTestFile);

	// File doesn't exist

	test(fs.SetAtt(KTestFile, KEntryAttReadOnly, 0) == KErrNotFound);

	// Create a file

	RFile file;

	test(file.Create(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

	file.Close();

	// Set readonly flag

	TUint att;

	test(fs.Att(KTestFile, att) == KErrNone);

	test(!(att&KEntryAttReadOnly));

	test(fs.SetAtt(KTestFile, KEntryAttReadOnly, 0) == KErrNone);

	test(fs.Att(KTestFile, att) == KErrNone && att&KEntryAttReadOnly);

	// Clear readonly flag

	test(fs.SetAtt(KTestFile, 0, KEntryAttReadOnly) == KErrNone);

	test(fs.Att(KTestFile, att) == KErrNone);

	test(!(att&KEntryAttReadOnly));

	test(fs.Delete(KTestFile) == KErrNone);

	fs.Close();

	}

void testModified()

	{

	// Connect to the file system

	RFs fs;

	test(fs.Connect() == KErrNone);

	// Make sure the file doesn't exist

	_LIT(KTestFile, "c:\\symport_test_rfs2a_test.txt");

	fs.Delete(KTestFile);

	// Get time now

	TTime start;

	start.UniversalTime();

	// File doesn't exist

	TTime time1;

	test(fs.Modified(KTestFile, time1) == KErrNotFound);

	User::After(1000000);

	// Create a file

	RFile file;

	test(file.Create(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

	file.Close();

	// Get modified time

	test(fs.Modified(KTestFile, time1) == KErrNone && time1 > start);

	User::After(1000000);

	// Edit the file

	test(file.Open(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

	file.Close();

	// Get modified time

	TTime time2;

	test(fs.Modified(KTestFile, time2) == KErrNone && time2 > time1);

	test(fs.Delete(KTestFile) == KErrNone);

	fs.Close();

	}

void testMkDirAll()

	{

	RFs fs;

	test(fs.Connect() == KErrNone);

	_LIT(KTestFile, "c:\\symport_test_rfs3_parent\\symport_test_rfs3_child");

	fs.Delete(KTestFile);

	// Make sure the directories don't exist already

	_LIT(KTestDirParent1, "c:\\symport_test_rfs3_parent\\");

	_LIT(KTestDir1, "c:\\symport_test_rfs3_parent\\symport_test_rfs3_child\\");

	fs.RmDir(KTestDir1);

	fs.RmDir(KTestDirParent1);

	// Check it can handle drive letter

	test(fs.MkDirAll(KTestDir1) == KErrNone);

	test(fs.MkDirAll(KTestDir1) == KErrAlreadyExists);

	TUint att;

	test(fs.Att(KTestDir1, att) == KErrNone && att&KEntryAttDir);	

	// Delete the folder for the next test

	test(fs.RmDir(KTestDir1) == KErrNone && fs.RmDir(KTestDirParent1) == KErrNone);

	TInt err = fs.Att(KTestDir1, att);

	test(err == KErrNotFound || err == KErrPathNotFound);	

	// Check it fails if file is encountered

	test(fs.MkDir(KTestDirParent1) == KErrNone);

	RFile file;

	test(file.Create(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

	file.Close();

	test(fs.MkDirAll(KTestDir1) == KErrAccessDenied);

	// Check for failure on itermediate file

	_LIT(KTestDir3, "c:\\symport_test_rfs3_parent\\symport_test_rfs3_child\\wibble\\");

	test(fs.MkDirAll(KTestDir3) == KErrAccessDenied);

	test(fs.Delete(KTestFile) == KErrNone);

	test(fs.RmDir(KTestDirParent1) == KErrNone);

	fs.Close();

	}

void testMkDir()

	{

	RFs fs;

	test(fs.Connect() == KErrNone);

	_LIT(KTestDir1, "c:\\symport_test_rfs5\\");

	_LIT(KTestFile, "c:\\symport_test_rfs5");

	_LIT(KTestDir1Sub, "c:\\symport_test_rfs5\\sub\\");

	// Make sure the test stuff doesn't exist already

	fs.RmDir(KTestDir1Sub);

	fs.Delete(KTestFile);

	fs.RmDir(KTestDir1);

	// Check the directory can be created

	TUint att;

	test(fs.MkDir(KTestDir1) == KErrNone);

	test(fs.MkDir(KTestDir1) == KErrAlreadyExists);

	test(fs.Att(KTestDir1, att) == KErrNone);	

	test(fs.MkDir(KTestDir1Sub) == KErrNone);

	test(fs.MkDir(KTestDir1Sub) == KErrAlreadyExists);

	test(fs.RmDir(KTestDir1Sub) == KErrNone);

	test(fs.RmDir(KTestDir1) == KErrNone);

	test(fs.Att(KTestDir1, att) == KErrNotFound);	

	// Check file error

	RFile file;

	test(file.Create(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

	file.Close();

	test(fs.MkDir(KTestDir1) == KErrAccessDenied);

	test(fs.Delete(KTestFile) == KErrNone);

	fs.Close();

	}

void testRmDir()

	{

	RFs fs;

	test(fs.Connect() == KErrNone);

	// Make sure the test stuff isn't there

	_LIT(KTestDir1, "c:\\symport_test_rfs6\\");

	_LIT(KTestFile, "c:\\symport_test_rfs6\\testfile");

	_LIT(KTestDir3, "c:\\symport_test_rfs6\\testfile\\");

	fs.Delete(KTestFile);

	fs.RmDir(KTestDir1);

	// Create the directory and make sure you can delete it

	TUint att;

	test(fs.MkDir(KTestDir1) == KErrNone);

	test(fs.Att(KTestDir1, att) == KErrNone && att|KEntryAttDir);	

	test(fs.RmDir(KTestDir1) == KErrNone);

	test(fs.RmDir(KTestDir1) == KErrNotFound);

	test(fs.Att(KTestDir1, att) == KErrNotFound);	

	test(fs.MkDir(KTestDir1) == KErrNone);

	test(fs.Att(KTestDir1, att) == KErrNone && att|KEntryAttDir);	

	RFile file;

	test(file.Create(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

	file.Close();

	// Check you can't delete a file or a none empty directory

	TInt err = fs.RmDir(KTestDir3);

	test(err == KErrNotFound || err == KErrPathNotFound);

	test(fs.RmDir(KTestDir1) == KErrInUse);

	test(fs.Delete(KTestFile) == KErrNone);

	test(fs.RmDir(KTestDir1) == KErrNone);

	// KErrInUse when removing a root directory

	test(fs.RmDir(_L("c:\\")) == KErrInUse);

	fs.Close();

	}

void testParse()

	{

	RFs fs;

	test(fs.Connect() == KErrNone);

	_LIT(KTestFile, "c:\\symport_test_rfs7.txt");

	fs.Delete(KTestFile);

	// Parse file spec

	TParse parse;

	test(fs.Parse(KTestFile, parse) == KErrNone);

	// See if we can create the  file

	RFile file;

	test(file.Create(fs, parse.FullName(), EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

	file.Close();

	test(fs.Delete(parse.FullName()) == KErrNone);

	fs.Close();

	}

void testSessionPath()

	{

	RFs fs;

	test(fs.Connect() == KErrNone);

	// Check we get a session path

	TFileName name;

	test(fs.SessionPath(name) == KErrNone);

	test(name.Length() > 0);

	// Check there's a backslash on the end and no forward slashes

	test(name[name.Length() - 1] == TChar('\\'));

	test(name.Locate(TChar('/')) == KErrNotFound);

	fs.Close();

	}

void testSetSessionPath()

	{

	RFs fs;

	test(fs.Connect() == KErrNone);

	_LIT(KTestDir1, "c:\\symport_test_rfs8\\");

	_LIT(KTestFile1, "c:\\symport_test_rfs8\\test");

	_LIT(KTestFilename1, "test");

	fs.Delete(KTestFile1);

	fs.RmDir(KTestDir1);

	// Check we get a session path

	TFileName name;

	test(fs.SessionPath(name) == KErrNone);

	test(name.Length() > 0);

	// Check we can set it

	fs.SetSessionPath(KTestDir1);

	test(fs.MkDir(KTestDir1) == KErrNone);

	test(fs.SetSessionPath(KTestDir1) == KErrNone);

	// See if we can create a file in the session path

	RFile file;

	test(file.Create(fs, KTestFilename1, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

	file.Close();

	// Check the file is there

	TUint att;

	test(fs.Att(KTestFile1, att) == KErrNone);

	test(fs.Delete(KTestFilename1) == KErrNone);

	// Reset session path!

	test(fs.SetSessionPath(name) == KErrNone);

	test(fs.RmDir(KTestDir1) == KErrNone);

	fs.Close();

	}

void testDelete()

	{

	RFs fs;

	test(fs.Connect() == KErrNone);

	_LIT(KTestDir, "c:\\symport_test_rfs9\\");

	_LIT(KTestFile, "c:\\symport_test_rfs9");

	fs.Delete(KTestFile);

	fs.RmDir(KTestDir);

	// Error if the file doesn't exist

	test(fs.Delete(KTestFile) == KErrNotFound);

	// Create the file

	RFile file;

	test(file.Create(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(_L8("test")) == KErrNone);

// On Linux it seems it's perfectly correct to "delete" an open file

// Removing an open file is sometimes recommended to hide the names of temporary files that may be prone to attack!

	TInt err = 0;

#ifndef linux

	// Should be locked

	err = fs.Delete(KTestFile);

	test(err == KErrInUse || err == KErrAccessDenied);

#endif

	file.Close();

	// Check success

	test(fs.Delete(KTestFile) == KErrNone);

	test(fs.Delete(KTestFile) == KErrNotFound);

	// Check you can't delete a directory

	test(fs.MkDir(KTestDir) == KErrNone);

	test(fs.Delete(KTestFile) == KErrAccessDenied);

	err = fs.Delete(KTestDir);

	test(err == KErrBadName || err == KErrAccessDenied);

	test(fs.RmDir(KTestDir) == KErrNone);

	fs.Close();

	}

// This is only valid for TOOLS2

#ifdef __TOOLS2__

extern TInt gBlockSize;

extern TInt gClusterSize;

void testVolumeIOParam()

	{

	RFs fs;

	test(fs.Connect() == KErrNone);

	// We rely on this error code being returned - preventing STORE cleverness?

	TVolumeIOParamInfo param;

	param.iBlockSize = 0;

	param.iClusterSize = 0;

	param.iRecReadBufSize = 0;

	param.iRecWriteBufSize = 0;

	test(fs.VolumeIOParam(EDriveC, param) == KErrNone);

	test(param.iBlockSize == 4096);

	test(param.iClusterSize == 4096);

	test(param.iRecReadBufSize == 4096);

	test(param.iRecWriteBufSize == 4096);

	gBlockSize = 8096;

	gClusterSize = 8096;

	test(fs.VolumeIOParam(EDriveC, param) == KErrNone);

	test(param.iBlockSize == 8096);

	test(param.iClusterSize == 8096);

	test(param.iRecReadBufSize == 4096);

	test(param.iRecWriteBufSize == 4096);

	fs.Close();

	}

#endif

void testEntry()

	{

	RFs fs;

	test(fs.Connect() == KErrNone);

	_LIT(KTestFile, "c:\\symport_test_rfs10");

	_LIT(KTestDir, "c:\\symport_test_rfs10_dir\\");

	fs.Delete(KTestFile);

	fs.RmDir(KTestDir);

	// Check error when file doesn't exist

	TEntry entry;

	test(fs.Entry(KTestFile, entry) == KErrNotFound);

	// Create test data

	TUidType testUid(TUid::Uid(0x1), TUid::Uid(0x2), TUid::Uid(0x3));

	TCheckedUid checkedUid(testUid);

	TPckg<TCheckedUid> checkedUidBuf(checkedUid);

	// Create the file

	RFile file;

	test(file.Create(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(checkedUidBuf) == KErrNone);

	file.Close();

	// Get file details

	User::After(1000000);

	test(fs.Entry(KTestFile, entry) == KErrNone);

	// Check the data looks right

	test(entry.iSize == checkedUidBuf.Length());

	test(entry.iType == testUid);

	test(entry.iName == KTestFile().Mid(3)); // No path

	test(!(entry.iAtt&KEntryAttDir));

	TTimeIntervalSeconds sec;

	TTime now; now.UniversalTime();

	test(now.SecondsFrom(entry.iModified, sec) == KErrNone);

	test(sec.Int() >= 1);

	_LIT8(KTestText, "Some junk that is not a uid");

	User::After(2000000);

	test(file.Replace(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);

	test(file.Write(KTestText) == KErrNone);

	file.Close();

	// Get file details

	test(fs.Entry(KTestFile, entry) == KErrNone);

	// Check the data looks right

	test(entry.iSize == KTestText().Length());

	test(entry.iType == TUidType(TUid::Uid(0), TUid::Uid(0), TUid::Uid(0)));

	test(entry.iName == KTestFile().Mid(3)); // No path

	test(now.SecondsFrom(entry.iModified, sec) == KErrNone);

	test(sec.Int() <= -1);

	// Test it works for directories

	test(fs.Entry(KTestDir, entry) == KErrNotFound);

	test(fs.MkDir(KTestDir) == KErrNone);

	test(fs.Entry(KTestDir, entry) == KErrNone);

	test(entry.iSize == 0);

	test(entry.iType == TUidType(TUid::Null(), TUid::Null(), TUid::Null()));

	test(entry.iName == KTestDir().Mid(3, KTestDir().Length() - 4)); // Lose path and end slash

	test(entry.iAtt&KEntryAttDir);

	test(fs.Delete(KTestFile) == KErrNone);

	test(fs.RmDir(KTestDir) == KErrNone);

	fs.Close();

	}

void testSetEntry()

	{

	// Connect to the file system

	RFs fs;

	test(fs.Connect() == KErrNone);