--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/symfile/test.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,2676 @@
+// Copyright (c) 1997-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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// 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);
+	
+	TTime start;
+	start.UniversalTime();
+	
+	// Make sure the file doesn't exist
+	_LIT(KTestFile, "c:\\symport_test_rfs2b_test.txt");
+	fs.SetEntry(KTestFile, start, 0, KEntryAttReadOnly);
+	fs.Delete(KTestFile);
+
+	// File doesn't exist
+	test(fs.SetEntry(KTestFile, start, 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 && !(att&KEntryAttReadOnly));
+	test(fs.SetEntry(KTestFile, start, KEntryAttReadOnly, 0) == KErrNone);
+	test(fs.Att(KTestFile, att) == KErrNone && att&KEntryAttReadOnly);
+
+	// Clear readonly flag
+	test(fs.SetEntry(KTestFile, start, 0, KEntryAttReadOnly) == KErrNone);
+	test(fs.Att(KTestFile, att) == KErrNone && !(att&KEntryAttReadOnly));
+	
+	test(fs.Delete(KTestFile) == KErrNone);
+	fs.Close();
+	}
+
+// Only relevant to TOOLS2
+#ifdef __TOOLS2__
+void testSetErrorCondition()
+	{
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	test(fs.SetErrorCondition(KErrGeneral, 1) == KErrNotSupported);
+	fs.Close();	
+	}
+#endif
+
+void testCharToDrive()
+	{
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	TInt drive;
+	
+	// Test invalid
+	test(fs.CharToDrive(TChar('$'), drive) == KErrArgument);
+	
+	// Test valid - upper and lower case
+	test(fs.CharToDrive(TChar('a'), drive) == KErrNone && drive == EDriveA);
+	test(fs.CharToDrive(TChar('A'), drive) == KErrNone && drive == EDriveA);
+	test(fs.CharToDrive(TChar('z'), drive) == KErrNone && drive == EDriveZ);
+	test(fs.CharToDrive(TChar('Z'), drive) == KErrNone && drive == EDriveZ);
+	
+	fs.Close();	
+	}
+
+void testDriveToChar()
+	{
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	TChar dChar;
+	
+	// Test invalid
+	test(fs.DriveToChar(99, dChar) == KErrArgument);
+	
+	// Ask for default drive
+	test(fs.DriveToChar(KDefaultDrive, dChar) == KErrNone);
+
+	test(TUint(dChar) >= TUint(TChar('A')));
+
+	test(TUint(dChar) <= TUint(TChar('Z')));
+
+	// Check valid
+	test(fs.DriveToChar(EDriveA, dChar) == KErrNone && dChar == TChar('A'));
+	test(fs.DriveToChar(EDriveZ, dChar) == KErrNone && dChar == TChar('Z'));
+	
+	fs.Close();	
+	}
+
+void testIsValidDrive()
+	{
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	// Invalid
+	test(!fs.IsValidDrive(99));
+	test(!fs.IsValidDrive(-99));
+	
+	// Valid
+	test(fs.IsValidDrive(KDefaultDrive));
+	test(fs.IsValidDrive(EDriveA));
+	test(fs.IsValidDrive(EDriveZ));
+	
+	fs.Close();	
+	}
+
+void testDrive()
+	{
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	// Test invalid drive
+	TDriveInfo drive;
+	test(fs.Drive(drive, 99) == KErrBadName);
+	
+#ifdef __TOOLS2__
+	// Test valid drives
+	test(fs.Drive(drive, EDriveC) == KErrNone);
+	test(drive.iType == EMediaHardDisk && drive.iBattery == EBatNotSupported && drive.iDriveAtt&KDriveAttLocal|KDriveAttInternal && drive.iMediaAtt == 0);
+	test(fs.Drive(drive, KDefaultDrive) == KErrNone);
+	test(drive.iType == EMediaHardDisk && drive.iBattery == EBatNotSupported && drive.iDriveAtt&KDriveAttLocal|KDriveAttInternal && drive.iMediaAtt == 0);
+#endif
+	
+	fs.Close();	
+	}
+
+void testGetSystemDrive()
+	{
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	test(fs.GetSystemDrive() == EDriveC);
+	test(fs.GetSystemDriveChar() == TChar('C'));
+	fs.Close();
+	}
+
+void testReplace()
+	{
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+
+	_LIT(KTestFile1, "c:\\symport_test_rfs11a");
+	_LIT(KTestFile2, "c:\\symport_test_rfs11b");
+	
+	fs.Delete(KTestFile1);
+	fs.Delete(KTestFile2);
+	
+	// Error when file doesn't exist
+	test(fs.Replace(KTestFile1, KTestFile2) == KErrNotFound);
+	
+	RFile file;
+	test(file.Create(fs, KTestFile1, EFileShareAny|EFileWrite) == KErrNone);
+	test(file.Write(_L8("test")) == KErrNone);
+	file.Close();
+
+	// Test success
+	test(fs.Replace(KTestFile1, KTestFile2) == KErrNone);
+	
+	TUint att;
+	test(fs.Att(KTestFile1, att) == KErrNotFound);
+	test(fs.Att(KTestFile2, att) == KErrNone);
+	test(fs.Replace(KTestFile2, KTestFile1) == KErrNone);
+	test(fs.Att(KTestFile1, att) == KErrNone);
+	test(fs.Att(KTestFile2, att) == KErrNotFound);
+
+	// Test when both files exist
+	test(file.Create(fs, KTestFile2, EFileShareAny|EFileWrite) == KErrNone);
+	test(file.Write(_L8("test")) == KErrNone);
+	file.Close();
+	
+	test(fs.Att(KTestFile1, att) == KErrNone);
+	test(fs.Att(KTestFile2, att) == KErrNone);
+	test(fs.Replace(KTestFile1, KTestFile2) == KErrNone);
+	test(fs.Att(KTestFile1, att) == KErrNotFound);
+	test(fs.Att(KTestFile2, att) == KErrNone);
+
+	test(fs.Replace(KTestFile2, KTestFile1) == KErrNone);
+	test(fs.Att(KTestFile1, att) == KErrNone);
+	test(fs.Att(KTestFile2, att) == KErrNotFound);
+
+	test(fs.Delete(KTestFile1) == KErrNone);
+	fs.Close();
+	}
+
+void testRename()
+	{
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	_LIT(KTestFile1, "c:\\symport_test_rfs12a");
+	_LIT(KTestFile2, "c:\\symport_test_rfs12b");
+
+	_LIT(KTestDir1, "c:\\symport_test_rfs12a\\");
+	_LIT(KTestDir2, "c:\\symport_test_rfs12b\\");
+
+	fs.Delete(KTestFile1);
+	fs.Delete(KTestFile2);
+	fs.RmDir(KTestDir1);
+	fs.RmDir(KTestDir2);
+	
+	// Error when source doesn't exist
+	test(fs.Rename(KTestFile1, KTestFile2) == KErrNotFound);
+	
+	// Error when destination does exist
+	RFile file;
+	test(file.Create(fs, KTestFile1, EFileShareAny|EFileWrite) == KErrNone);
+	test(file.Write(_L8("test")) == KErrNone);
+	file.Close();
+
+	test(file.Create(fs, KTestFile2, EFileShareAny|EFileWrite) == KErrNone);
+	test(file.Write(_L8("test")) == KErrNone);
+	file.Close();
+
+	test(fs.Rename(KTestFile1, KTestFile2) == KErrAlreadyExists);
+	test(fs.Delete(KTestFile2) == KErrNone);
+	
+	// Test Success
+	test(fs.SetAtt(KTestFile1, 0, KEntryAttReadOnly) == KErrNone);
+	test(fs.Rename(KTestFile1, KTestFile2) == KErrNone);
+
+	TUint att;
+	test(fs.Att(KTestFile1, att) == KErrNotFound);
+	test(fs.Att(KTestFile2, att) == KErrNone);
+	test(fs.Rename(KTestFile2, KTestFile1) == KErrNone);
+	test(fs.Att(KTestFile1, att) == KErrNone);
+	test(fs.Att(KTestFile2, att) == KErrNotFound);
+
+	test(fs.Delete(KTestFile1) == KErrNone);
+		
+	fs.Close();	
+	}
+
+TPtrC test_string=_L("Y:\\");
+LOCAL_C void TestTParse1()
+//
+// Test all TParse methods
+//
+	{
+	TBuf<16> relatedFiles(_L(".CCC"));
+	TBuf<16> defaultPath(_L("C:\\"));
+	TParse parser;
+	TInt r=parser.Set(_L("\\WWW\\XXX\\YYY\\ZZZ\\AAA"),&relatedFiles,&defaultPath);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\WWW\\XXX\\YYY\\ZZZ\\AAA.CCC"));
+	test(parser.Drive()==_L("C:"));
+	test(parser.Path()==_L("\\WWW\\XXX\\YYY\\ZZZ\\"));
+	test(parser.DriveAndPath()==_L("C:\\WWW\\XXX\\YYY\\ZZZ\\"));
+	test(parser.Name()==_L("AAA"));
+	test(parser.Ext()==_L(".CCC"));
+	test(parser.NameAndExt()==_L("AAA.CCC"));
+	test(parser.DrivePresent()==EFalse);
+	test(parser.PathPresent());
+	test(parser.NamePresent());
+	test(parser.ExtPresent()==EFalse);
+	test(parser.NameOrExtPresent());
+	test(parser.IsRoot()==EFalse);
+	test(parser.IsWild()==EFalse);
+	test(parser.IsNameWild()==EFalse);
+	test(parser.IsExtWild()==EFalse);
+	r=parser.SetNoWild(_L("\\WWW\\XXX\\YYY\\ZZZ\\AAA.EXT"),&relatedFiles,&defaultPath);
+	test(r==KErrNone);
+	test(parser.PopDir()==KErrNone);
+	test(parser.AddDir(_L("BBB"))==KErrNone);
+	}
+
+LOCAL_C void TestTParse2()
+//
+// Test multiple PopDirs
+//
+	{
+
+	TParse parser;
+	TInt r=parser.Set(_L("\\WWW\\XXX\\YYY\\ZZZ\\"),NULL,NULL);
+//	TParsePtrC parser(_L("\\WWW\\XXX\\YYY\\ZZZ\\"));
+	test(r==KErrNone);
+	r=parser.PopDir();
+	test(r==KErrNone);
+	test(parser.Path()==_L("\\WWW\\XXX\\YYY\\"));
+	r=parser.PopDir();
+	test(r==KErrNone);
+	test(parser.Path()==_L("\\WWW\\XXX\\"));
+	r=parser.PopDir();
+	test(r==KErrNone);
+	test(parser.Path()==_L("\\WWW\\"));
+	r=parser.PopDir();
+	test(r==KErrNone);
+	test(parser.Path()==_L("\\"));
+	r=parser.PopDir();
+	test(r==KErrGeneral);
+//
+	test(parser.Set(_L("C:\\Documents\\.TXT"),NULL,NULL)==KErrNone);
+	test(parser.PopDir()==KErrNone);
+	test(parser.FullName()==_L("C:\\.TXT"));
+	}
+
+LOCAL_C void TestTParse3()
+//
+// Test conflicting drive letters
+//
+	{
+
+	TParse parser;
+    TPtrC one=_L("\\ONE\\");
+    TPtrC null=_L("\\");
+    TPtrC x=_L("X:");
+    TPtrC x2=_L("X:\\");
+    TPtrC z=_L("Z:");
+	TInt r=parser.Set(_L("Z:\\Hello"),&one,&null);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("Z:\\Hello"));
+    TPtrC sht=_L("*.SHT");
+    r=parser.Set(_L("Z:"),&sht,&x);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("Z:*.SHT"));
+	r=parser.Set(_L("Hello"),&z,&x2);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("Z:\\Hello"));
+	r=parser.Set(_L("W:\\Hello"),&z,&x2);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("W:\\Hello"));
+    TPtrC abcdefg=_L("abcdefg");
+    TPtrC onetwo=_L("X:\\ONE\\TWO\\.CCC");
+	r=parser.Set(_L("W:"),&abcdefg,&onetwo);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("W:\\ONE\\TWO\\abcdefg.CCC"));
+    TPtrC y=_L("Y:");
+    TPtrC xhello=_L("X:\\HELLO\\");
+    r=parser.Set(_L("World"),&y,&xhello);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("Y:\\HELLO\\World"));
+    TPtrC xhelloext=_L("X:\\HELLO\\.EXT");
+    r=parser.Set(_L("World"),&y,&xhelloext);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("Y:\\HELLO\\World.EXT"));
+	}
+
+LOCAL_C void TestTParse4()
+//
+// Conflicting relative path drives and names
+//
+	{
+
+	TParse parser;
+    TPtrC xone=_L("X:\\ONE\\");
+    TPtrC y=_L("Y:\\");
+	TInt r=parser.Set(_L("Z:\\Hello"),&xone,&y);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("Z:\\Hello"));
+    TPtrC zone=_L("Z:\\ONE\\");
+    TPtrC xnew=_L("X:\\NEW\\");
+    r=parser.Set(_L("\\Hello"),&zone,&xnew);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("Z:\\Hello"));
+    TPtrC aone=_L("A:\\ONE\\");
+    TPtrC anew=_L("A:\\NEW\\");
+    r=parser.Set(_L("A:Hello"),&aone,&anew);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("A:\\ONE\\Hello"));
+    TPtrC a=_L("A:\\");
+    r=parser.Set(_L("Hello"),&a,&xnew);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("A:\\Hello"));
+	r=parser.Set(_L("Hello"),&aone,&xnew);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("A:\\ONE\\Hello"));
+	}
+
+
+LOCAL_C void TestTParse5()
+//
+// Test illegal paths
+//
+	{
+
+	TParse parser;
+	TInt r=parser.Set(_L("FOO\\"),NULL,NULL);
+	test(r==KErrBadName);
+	r=parser.Set(_L("C:\\FOO\\\\"),NULL,NULL);
+	test(r==KErrNone);
+	}
+
+LOCAL_C void TestTParse6()
+//
+// Test AddDir
+//
+	{
+
+	TParse parser;
+	test(parser.Set(_L("C:\\"),NULL,NULL)==KErrNone);
+	test(parser.IsRoot());
+	test(parser.FullName()==_L("C:\\"));
+	test(parser.AddDir(_L("HELLO"))==KErrNone);
+	test(parser.IsRoot()==EFalse);
+	test(parser.FullName()==_L("C:\\HELLO\\"));
+	test(parser.AddDir(_L("BYEBYE"))==KErrNone);
+	test(parser.IsRoot()==EFalse);
+	test(parser.FullName()==_L("C:\\HELLO\\BYEBYE\\"));
+	test(parser.PopDir()==KErrNone);
+	test(parser.IsRoot()==EFalse);
+	test(parser.FullName()==_L("C:\\HELLO\\"));
+	test(parser.PopDir()==KErrNone);
+	test(parser.IsRoot());
+	test(parser.FullName()==_L("C:\\"));
+//
+	test(parser.AddDir(_L(""))==KErrNone);
+	test(parser.IsRoot());
+	test(parser.FullName()==_L("C:\\"));
+	test(parser.AddDir(_L("HELLO"))==KErrNone);
+	test(parser.IsRoot()==EFalse);
+	test(parser.FullName()==_L("C:\\HELLO\\"));
+	test(parser.AddDir(_L(""))==KErrNone);
+	test(parser.IsRoot()==EFalse);
+	test(parser.FullName()==_L("C:\\HELLO\\"));
+//
+	test(parser.Set(_L("C:\\Documents\\.TXT"),NULL,NULL)==KErrNone);
+	test(parser.AddDir(_L("Documents"))==KErrNone);
+	test(parser.FullName()==_L("C:\\Documents\\Documents\\.TXT"));
+	}
+
+LOCAL_C void TestTParse7()
+//
+// Test TParsePtr
+//
+	{
+
+	TBuf<128> nameBuf=_L("C:\\WWW\\XXX\\YYY\\ZZZ\\AAA.CCC");
+	TParsePtr parser(nameBuf);
+
+	test(parser.FullName()==_L("C:\\WWW\\XXX\\YYY\\ZZZ\\AAA.CCC"));
+	test(parser.Drive()==_L("C:"));
+	test(parser.Path()==_L("\\WWW\\XXX\\YYY\\ZZZ\\"));
+	test(parser.DriveAndPath()==_L("C:\\WWW\\XXX\\YYY\\ZZZ\\"));
+	test(parser.Name()==_L("AAA"));
+	test(parser.Ext()==_L(".CCC"));
+	test(parser.NameAndExt()==_L("AAA.CCC"));
+	test(parser.DrivePresent());
+	test(parser.PathPresent());
+	test(parser.NamePresent());
+	test(parser.ExtPresent());
+	test(parser.NameOrExtPresent());
+	test(parser.IsRoot()==EFalse);
+	test(parser.IsWild()==EFalse);
+	test(parser.IsNameWild()==EFalse);
+	test(parser.IsExtWild()==EFalse);
+	
+	test(parser.AddDir(_L("HELLO"))==KErrNone);
+	test(parser.Path()==_L("\\WWW\\XXX\\YYY\\ZZZ\\HELLO\\"));
+
+	TBuf<16> shortName=_L("1234567812345678");
+	TParsePtr parser2(shortName);
+	test(parser2.FullName()==_L("1234567812345678"));
+	test(parser2.Path()==_L(""));
+	test(parser2.DriveAndPath()==_L(""));
+	test(parser2.Ext()==_L(""));
+	test(parser2.Name()==_L("1234567812345678"));
+	test(parser2.AddDir(_L("TOOBIG"))==KErrGeneral);
+	}
+
+LOCAL_C void TestTParse8()
+//
+// Test TParsePtrC
+//
+	{
+	
+	TBuf<128> nameBuf=_L("C:\\WWW\\XXX\\YYY\\ZZZ\\AAA.CCC");
+	TParsePtrC parser(nameBuf);
+
+	test(parser.FullName()==_L("C:\\WWW\\XXX\\YYY\\ZZZ\\AAA.CCC"));
+	test(parser.Drive()==_L("C:"));
+	test(parser.Path()==_L("\\WWW\\XXX\\YYY\\ZZZ\\"));
+	test(parser.DriveAndPath()==_L("C:\\WWW\\XXX\\YYY\\ZZZ\\"));
+	test(parser.Name()==_L("AAA"));
+	test(parser.Ext()==_L(".CCC"));
+	test(parser.NameAndExt()==_L("AAA.CCC"));
+	test(parser.DrivePresent());
+	test(parser.PathPresent());
+	test(parser.NamePresent());
+	test(parser.ExtPresent());
+	test(parser.NameOrExtPresent());
+	test(parser.IsRoot()==EFalse);
+	test(parser.IsWild()==EFalse);
+	test(parser.IsNameWild()==EFalse);
+	test(parser.IsExtWild()==EFalse);
+	}
+
+LOCAL_C void TestTParse9()
+//
+// Test names with leading spaces
+//
+	{
+
+	TParse parser;
+	TBuf<16> nameBuf=_L("   name.txt");
+	TBuf<16> pathBuf=_L("\\PATH\\");
+	
+	TInt r=parser.Set(pathBuf,NULL,&nameBuf);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("\\PATH\\   name.txt"));
+	r=parser.Set(_L(""),&nameBuf,&pathBuf);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("\\PATH\\   name.txt"));
+	r=parser.Set(_L("   name.txt"),NULL,&pathBuf);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("\\PATH\\   name.txt"));
+	r=parser.Set(nameBuf,&pathBuf,NULL);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("\\PATH\\   name.txt"));
+	
+	TBuf<16> badPath=_L("   \\PATH\\");
+	r=parser.Set(_L("C:\\"),NULL,&badPath);
+	test(r==KErrBadName);
+	r=parser.Set(_L("C:\\"),&badPath,NULL);
+	test(r==KErrBadName);
+
+	TBuf<16> spacePath=_L("\\  PATH\\");
+	r=parser.Set(_L("C:"),&nameBuf,&spacePath);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\  PATH\\   name.txt"));
+
+	TBuf<32> spacename=_L("\\  name   .   txt  ");
+	r=parser.Set(_L("C:"),&spacename,NULL);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\  name   .   txt"));
+
+// Illegal (?) values
+
+	TBuf<16> pureSpace=_L("     ");
+	r=parser.Set(_L("C:\\NAME\\"),NULL,&pureSpace);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\NAME\\")); // Trims right off name
+	r=parser.Set(_L("C:\\NAME\\   "),NULL,NULL);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\NAME\\"));
+
+	TBuf<16> spacePlusExt=_L("    .   ext  ");
+	r=parser.Set(_L("C:\\NAME\\"),NULL,&spacePlusExt);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\NAME\\    .   ext")); // Trims right off ext
+	r=parser.Set(_L("C:\\NAME\\    .   ext   "),NULL,NULL);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\NAME\\    .   ext"));
+
+	TBuf<32> pathSpace=_L("\\asdf\\zxcv\\   \\asdf\\");
+	r=parser.Set(_L("C:"),NULL,&pathSpace);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\asdf\\zxcv\\   \\asdf\\")); // Leaves spaces in path
+	r=parser.Set(_L("C:\\NAME\\ \\alt.sdf"),NULL,NULL);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\NAME\\ \\alt.sdf"));
+
+
+	TBuf<32> zeroPath=_L("\\asdf\\wqer\\\\asdf\\");
+	r=parser.Set(_L("NAME.TXT"),NULL,&zeroPath);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("\\asdf\\wqer\\\\asdf\\NAME.TXT")); // Leaves zerolength path
+	r=parser.Set(_L("C:\\NAME\\\\alt.sdf"),NULL,NULL);
+	test(r==KErrNone);
+	test(parser.FullName()==_L("C:\\NAME\\\\alt.sdf"));
+	}
+
+LOCAL_C void TestTParse10()
+//
+// Test a very long path
+//
+	{
+
+	TBuf<16> pathPart=_L("\\2345678");
+	TBuf<512> testPath;
+
+	for(TInt i=0;i<63;i++)
+		testPath+=pathPart;
+
+	RFs fs;
+	TInt r=fs.Connect();
+	test(r==KErrNone);
+	TParse parse;
+	r=fs.Parse(testPath,parse);
+	test(r==KErrBadName);
+	fs.Close();
+
+	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=parse.Set(longFileName,&test_string,NULL);
+	test(r==KErrNone);
+	r=parse.PopDir();
+	test(r==KErrNone);
+
+	longFileName[123]='\\';
+	r=parse.Set(longFileName,&test_string,NULL);
+	test(r==KErrNone);
+	r=parse.PopDir();
+	test(r==KErrNone);
+	TPtrC startPath((TText*)longFileName.Ptr(),124);
+	test(parse.Path()==startPath);
+
+	TPtrC endPath((TText*)longFileName.Ptr()+124,252-124+1);
+	r=parse.AddDir(endPath);
+	test(r==KErrNone);
+	test(parse.Path()==longFileName);
+	}
+
+LOCAL_C void testTFileTextApi()
+//
+// Test TFileText class methods
+//
+	{
+
+	TPtrC record[5];
+	record[0].Set(_L("First record"));
+	record[1].Set(_L("Second record"));
+	record[2].Set(_L("Third record"));
+	record[3].Set(_L("Fourth record"));
+	record[4].Set(_L("Fifth record"));
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	RFile f;
+	TInt r=f.Replace(fs,_L("TEXTFILE.TXT"),0);
+	test(r==KErrNone);
+	TFileText textFile;
+	textFile.Set(f);
+	TInt i=0;
+	for (i=0;i<5;i++)
+		{
+		r=textFile.Write(record[i]);
+		test(r==KErrNone);
+		}
+	r=textFile.Seek(ESeekStart);
+	test(r==KErrNone);
+	TBuf<16> recBuf;
+	for(i=0;i<5;i++)
+		{
+		r=textFile.Read(recBuf);
+		test(r==KErrNone);
+		test(recBuf==record[i]);
+		}
+	r=textFile.Read(recBuf);
+	test(r==KErrEof);
+	test(recBuf.Length()==0);
+	f.Close();
+
+	test.Next(_L("Test dosfile terminator"));
+	TPtrC8 trecord[7];
+	TPtrC tTextrecord[7];
+	tTextrecord[0].Set(_L("First record\r\n"));
+	tTextrecord[1].Set(_L("Second record\r\n"));
+	tTextrecord[2].Set(_L("Third record\r\n"));
+	tTextrecord[3].Set(_L("Fourth record\r\n"));
+	tTextrecord[4].Set(_L("Fifth record\r\n"));
+	tTextrecord[5].Set(_L("Sixth record\n\r"));
+	tTextrecord[6].Set(_L("Seventh record\n"));
+	trecord[0].Set((TUint8*)tTextrecord[0].Ptr(),tTextrecord[0].Length()*sizeof(TText));
+	trecord[1].Set((TUint8*)tTextrecord[1].Ptr(),tTextrecord[1].Length()*sizeof(TText));
+	trecord[2].Set((TUint8*)tTextrecord[2].Ptr(),tTextrecord[2].Length()*sizeof(TText));
+	trecord[3].Set((TUint8*)tTextrecord[3].Ptr(),tTextrecord[3].Length()*sizeof(TText));
+	trecord[4].Set((TUint8*)tTextrecord[4].Ptr(),tTextrecord[4].Length()*sizeof(TText));
+	trecord[5].Set((TUint8*)tTextrecord[5].Ptr(),tTextrecord[5].Length()*sizeof(TText));
+	trecord[6].Set((TUint8*)tTextrecord[6].Ptr(),tTextrecord[6].Length()*sizeof(TText));
+	r=f.Replace(fs,_L("TEXTFILE.TXT"),0);
+	test(r==KErrNone);
+	for(i=0;i<7;i++)
+		{
+		TBuf8<256> buf;
+		buf.Copy(trecord[i]);
+		r=f.Write(buf);
+		test(r==KErrNone);
+		}
+	textFile.Set(f);
+	textFile.Seek(ESeekStart);
+	for(i=0;i<5;i++)
+		{
+		r=textFile.Read(recBuf);
+		test(r==KErrNone);
+		test(recBuf==record[i]);
+		}
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==_L("Sixth record"));
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==_L("\rSeventh record"));
+	r=textFile.Read(recBuf);
+	test(r==KErrEof);
+	test(recBuf.Length()==0);
+	f.Close();
+
+	test.Next(_L("Test read with bufferSize == dataSize"));
+	r=f.Replace(fs,_L("TEXTFILE.TXT"),0);
+	test(r==KErrNone);
+	record[0].Set(_L("1234567890123456"));
+//	trecord[0].Set(_L8("1234567890123456\r\n"));
+//	trecord[1].Set(_L8("1234567890123456\n"));
+
+	TPtrC tmpTextrecord;
+	tmpTextrecord.Set(_L("1234567890123456\r\n"));
+	trecord[0].Set((TUint8*)tmpTextrecord.Ptr(),tmpTextrecord.Length()*sizeof(TText));
+
+	tmpTextrecord.Set(_L("1234567890123456\n"));
+	trecord[1].Set((TUint8*)tmpTextrecord.Ptr(),tmpTextrecord.Length()*sizeof(TText));
+
+	for (i=0;i<2;i++)
+		{
+		r=f.Write(trecord[i]);
+		test(r==KErrNone);
+		}
+	textFile.Set(f);
+	textFile.Seek(ESeekStart);
+	for(i=0;i<2;i++)
+		{
+		r=textFile.Read(recBuf);
+		test(r==KErrNone);
+		test(recBuf==record[0]);
+		}
+	r=textFile.Read(recBuf);
+	test(r==KErrEof);
+	test(recBuf.Length()==0);
+	f.Close();
+
+	test.Next(_L("Read into a buffer < recordSize"));
+	TBuf<8> smallBuf;
+	r=f.Open(fs,_L("TEXTFILE.txt"),0);
+	test(r==KErrNone);
+	textFile.Set(f);
+	for(i=0;i<2;i++)
+		{
+		r=textFile.Read(smallBuf);
+		test(r==KErrTooBig);
+		test(smallBuf==_L("12345678"));
+		}
+	f.Close();
+
+	test.Next(_L("Nasty cases: 1) split over buffer boundary"));
+	r=f.Replace(fs,_L("TEXTFILE.txt"),0);
+	test(r==KErrNone);
+	HBufC* largeRecord=HBufC::NewL(600);
+	largeRecord->Des().SetLength(250);
+	largeRecord->Des().Fill('A');
+	largeRecord->Des()[249]='\n';
+	TPtrC8 bufPtr;
+	bufPtr.Set((TUint8*)largeRecord->Ptr(),largeRecord->Size()); // Size() returns length in bytes
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+	TBuf<16> boundaryBuf=_L("12345\r\n");
+	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+	r=f.Write(trecord[0]);
+	test(r==KErrNone);
+
+	textFile.Set(f);
+	textFile.Seek(ESeekStart);
+	r=textFile.Read(recBuf);
+	test(r==KErrTooBig);
+	test(recBuf==_L("AAAAAAAAAAAAAAAA"));
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==_L("12345"));
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==record[0]);
+	f.Close();
+
+	test.Next(_L("Nasty cases: 2) on buffer boundary"));
+	r=f.Replace(fs,_L("TEXTFILE.txt"),0);
+	test(r==KErrNone);
+	largeRecord->Des().SetLength(250);
+	largeRecord->Des().Fill('A');
+	largeRecord->Des()[249]='\n';
+	bufPtr.Set((TUint8*)largeRecord->Ptr(),largeRecord->Size());
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+	boundaryBuf=_L("12345\rxyz\n");
+	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+	r=f.Write(trecord[0]);
+	test(r==KErrNone);
+
+	textFile.Set(f);
+	textFile.Seek(ESeekStart);
+	r=textFile.Read(recBuf);
+	test(r==KErrTooBig);
+	test(recBuf==_L("AAAAAAAAAAAAAAAA"));
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==_L("12345\rxyz"));
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==record[0]);
+	f.Close();
+
+	test.Next(_L("Nasty cases: 3) record size > buffer size"));
+	r=f.Replace(fs,_L("TEXTFILE.txt"),0);
+	test(r==KErrNone);
+	largeRecord->Des().SetLength(600);
+	largeRecord->Des().Fill('Z');
+	largeRecord->Des()[511]='\r';
+	largeRecord->Des()[599]='\n';
+	bufPtr.Set((TUint8*)largeRecord->Ptr(),largeRecord->Size());
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+	boundaryBuf=_L("12345\rxyz\n");
+	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+	r=f.Write(trecord[0]);
+	test(r==KErrNone);
+
+	textFile.Set(f);
+	textFile.Seek(ESeekStart);
+	r=textFile.Read(recBuf);
+	test(r==KErrTooBig);
+	test(recBuf==_L("ZZZZZZZZZZZZZZZZ"));
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==_L("12345\rxyz"));
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==record[0]);
+	
+	TBuf<601> bigBuf;
+	TPtrC largePtr((TText*)largeRecord->Ptr(),(largeRecord->Length()-1));
+	textFile.Seek(ESeekStart);
+	r=textFile.Read(bigBuf);
+	test(r==KErrNone);
+	test(bigBuf==largePtr);
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==_L("12345\rxyz"));
+	r=textFile.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf==record[0]);
+	f.Close();
+
+	User::Free(largeRecord);
+	test(fs.Delete(_L("TEXTFILE.txt")) == KErrNone);
+	fs.Close();
+	}
+
+LOCAL_C void testTFileTextEndRecord()
+//
+// Test terminating record
+//
+	{
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+
+	RFile f;
+	TInt r=f.Replace(fs,_L("TextFile"),0);
+	test(r==KErrNone);
+	TPtrC8 bufPtr;
+	TBuf<16>boundaryBuf=_L("Record1\n");
+	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());	
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+	boundaryBuf=_L("Record2\n");
+	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());	
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+	boundaryBuf=_L("Record3\n");
+	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());	
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+	
+	TFileText fText;
+	fText.Set(f);
+	r=fText.Seek(ESeekStart);
+	test(r==KErrNone);
+	TBuf<32> recBuf;
+	r=fText.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf.MatchF(_L("record1"))!=KErrNotFound);
+	r=fText.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf.MatchF(_L("record2"))!=KErrNotFound);
+	r=fText.Read(recBuf);
+	test(r==KErrNone);
+	test(recBuf.MatchF(_L("record3"))!=KErrNotFound);
+	r=fText.Read(recBuf);
+	test(r==KErrEof);
+	test(recBuf.Length()==0);
+	f.Close();
+
+	TBuf<0x100> bigBuf(0x100);
+	bigBuf.Fill('A');
+	r=f.Replace(fs,_L("TextFile"),0);
+	test(r==KErrNone);
+	
+    bufPtr.Set((TUint8*)bigBuf.Ptr(),bigBuf.Size());	
+	r=f.Write(bufPtr);
+	test(r==KErrNone);
+
+	fText.Set(f);
+	r=fText.Seek(ESeekStart);
+	test(r==KErrNone);
+	bigBuf.SetLength(0);
+	r=fText.Read(bigBuf);
+//	test.Printf(_L("fText.Read returns %d\n"),r);
+	test(r==KErrNone);
+//	test.Printf(_L("BigBuf.Length()==%d\n"),bigBuf.Length());
+	test(bigBuf.Length()==0x100);
+	r=fText.Read(bigBuf);
+	test(r==KErrEof);
+	test(bigBuf.Length()==0);
+	f.Close();
+	
+	test(fs.Delete(_L("TextFile")) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileOpen()
+	{
+	_LIT(KTestFile, "c:\\symport_test_rfile_open");
+	_LIT8(KTestText, "abcdefghijklmnopqrstuvwxyz");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+
+	fs.SetAtt(KTestFile, 0, KEntryAttReadOnly);
+	fs.Delete(KTestFile);
+	
+	// File doesn't exist
+	RFile file;
+	test(file.Open(fs, KTestFile, 0) == KErrNotFound);
+	
+	// Create the file
+	test(file.Create(fs, KTestFile, 0) == KErrNone);
+	test(file.Write(KTestText) == KErrNone);
+
+	// Should be okay to close a file twice
+	file.Close();
+	file.Close();
+	
+	// Open the file for reading
+	TBuf8<26> buf;
+	test(file.Open(fs, KTestFile, EFileShareAny) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+
+	// Check you can't write to it
+	test(file.Write(KTestText) == KErrAccessDenied);
+	
+	// Check another file can be opened at the same time
+	RFile file2;
+	test(file2.Open(fs, KTestFile, EFileShareAny) == KErrNone);	
+	test(file2.Read(buf) == KErrNone && buf == KTestText);
+	file2.Close();
+	test(file2.Open(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);	
+	file2.Close();
+	file.Close();
+	
+	// Open the file for writing
+	test(file.Open(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+	
+	// Check you can write to it
+	test(file.Write(KTestText) == KErrNone);
+	
+	// Check another file can be opened at the same time	
+	test(file2.Open(fs, KTestFile, EFileShareAny|EFileRead) == KErrNone);
+	file2.Close();
+	test(file2.Open(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);	
+	file2.Close();
+
+	// Read back what we just wrote
+	file.Close();
+	test(file.Open(fs, KTestFile, 0) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+	file.Close();
+	
+	// Check error on read only file
+	test(fs.SetAtt(KTestFile, KEntryAttReadOnly, 0) == KErrNone);
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrAccessDenied);
+	test(fs.SetAtt(KTestFile, 0, KEntryAttReadOnly) == KErrNone);	
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	file.Close();
+
+	test(fs.Delete(KTestFile) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileCreate()
+	{
+	_LIT(KTestFile, "c:\\symport_test_rfile_create");
+	_LIT8(KTestText, "abcdefghijklmnopqrstuvwxyz");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	fs.Delete(KTestFile);
+	
+	// Create should work when file doesn't exist
+	RFile file;
+	test(file.Create(fs, KTestFile, 0) == KErrNone);
+	test(file.Write(KTestText) == KErrNone);
+	file.Close();
+	
+	// Create should fail when file does exist
+	test(file.Create(fs, KTestFile, 0) == KErrAlreadyExists);
+	test(fs.Delete(KTestFile) == KErrNone);
+	
+	// Check you can read from the file
+	test(file.Create(fs, KTestFile, 0) == KErrNone);
+	test(file.Write(KTestText) == KErrNone);
+	TInt pos = 0;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	TBuf8<26> buf;
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+	test(file.Write(KTestText) == KErrNone);
+	pos = 26;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+	file.Close();
+
+	// Check error on read only file
+	test(fs.SetAtt(KTestFile, KEntryAttReadOnly, 0) == KErrNone);
+	test(file.Replace(fs, KTestFile, EFileWrite) == KErrAccessDenied);
+	test(fs.SetAtt(KTestFile, 0, KEntryAttReadOnly) == KErrNone);	
+	test(file.Replace(fs, KTestFile, EFileWrite) == KErrNone);
+	file.Close();
+
+	fs.Delete(KTestFile);
+	fs.Close();
+	}
+
+void testRFileReplace()
+	{
+	_LIT(KTestFile, "c:\\symport_test_rfile_replace");
+	_LIT8(KTestText, "abcdefghijklmnopqrstuvwxyz");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	fs.Delete(KTestFile);
+	
+	// Reaplce should work when file doesn't exist
+	RFile file;
+	test(file.Replace(fs, KTestFile, 0) == KErrNone);
+	test(file.Write(KTestText) == KErrNone);
+	file.Close();
+	
+	// Replace should also work when file does exist
+	test(file.Replace(fs, KTestFile, 0) == KErrNone);
+	test(file.Write(KTestText) == KErrNone);
+	
+	// Check you can read from the file
+	TInt pos = 0;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	TBuf8<26> buf;
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+	test(file.Write(KTestText) == KErrNone);
+	pos = 26;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+	file.Close();
+
+	fs.Delete(KTestFile);
+	fs.Close();
+	}
+
+void testRFileTemp()
+	{
+	_LIT(KTestDir, "c:\\symport_test_rfile_temp\\");
+	_LIT8(KTestText, "abcdefghijklmnopqrstuvwxyz");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	fs.MkDir(KTestDir);
+
+	TFileName f1;
+	RFile file;
+	
+	// Use invalid path
+	test(file.Temp(fs, _L("invalid"), f1, 0) == KErrBadName);
+	test(file.Temp(fs, _L("invalid\\"), f1, 0) == KErrBadName);
+	
+	// Try to use a file for the path
+	test(file.Replace(fs, _L("invalid"), 0) == KErrNone);
+	file.Close();
+	test(file.Temp(fs, _L("invalid"), f1, 0) == KErrBadName);
+	test(fs.Delete(_L("invalid")) == KErrNone);
+	
+	test(file.Temp(fs, KTestDir, f1, 0) == KErrNone);
+	test(file.Write(KTestText) == KErrNone);
+	file.Close();
+	
+	// Check it works a second time
+	TFileName f2;
+	test(file.Temp(fs, KTestDir, f2, 0) == KErrNone);
+	
+	// Check you can read from the file
+	test(file.Write(KTestText) == KErrNone);
+	TInt pos = 0;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	TBuf8<26> buf;
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+	test(file.Write(KTestText) == KErrNone);
+	pos = 26;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf == KTestText);
+	file.Close();
+
+	test(fs.Delete(f1) == KErrNone);
+	test(fs.Delete(f2) == KErrNone);
+
+	// See if you can create a temp on root
+	test(file.Temp(fs, _L("C:\\"), f1, 0) == KErrNone);
+	file.Close();
+	test(fs.Delete(f1) == KErrNone);
+
+	// See if empty path is okay
+	test(file.Temp(fs, KNullDesC, f1, 0) == KErrNone);
+	file.Close();
+	test(fs.Delete(f1) == KErrNone);
+
+	fs.RmDir(KTestDir);
+	fs.Close();
+	}
+
+void testRFileRead()
+	{
+	_LIT(KTestFile, "c:\\symport_test_rfile_read");
+	_LIT8(KTestText, "abcdefghijklmnopqrstuvwxyz");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+
+	// Create a test file
+	RFile file;
+	test(file.Replace(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Write(KTestText) == KErrNone);
+	file.Close();
+	
+	TBuf8<13> buf;
+	test(file.Open(fs, KTestFile, 0) == KErrNone);
+
+	// File position at the start
+	TInt pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+	
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 13 && buf == KTestText().Left(13));
+	
+	// Check file position is updated
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 13);
+	
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 13 && buf == KTestText().Right(13));
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 0);
+	
+	pos = 13;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 13 && buf == KTestText().Right(13));
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 0);
+
+	// Move back to the start
+	pos = 0;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	
+	test(file.Read(buf, 6) == KErrNone);
+	test(buf.Length() == 6 && buf == KTestText().Left(6));
+	pos = 20;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	test(file.Read(buf, 6) == KErrNone);
+	test(buf.Length() == 6 && buf == KTestText().Right(6));
+	test(file.Read(buf, 1) == KErrNone);
+	test(buf.Length() == 0);
+
+	test(file.Read(0, buf) == KErrNone);
+	test(buf.Length() == 13 && buf == KTestText().Left(13));
+	test(file.Read(13, buf) == KErrNone);
+	test(buf.Length() == 13 && buf == KTestText().Right(13));
+	test(file.Read(23, buf) == KErrNone);
+	test(buf.Length() == 3 && buf == KTestText().Right(3));
+	test(file.Read(27, buf) == KErrNone);
+	test(buf.Length() == 0);
+
+	test(file.Read(0, buf, 6) == KErrNone);
+	test(buf.Length() == 6 && buf == KTestText().Left(6));
+	test(file.Read(20, buf, 6) == KErrNone);
+	test(buf.Length() == 6 && buf == KTestText().Right(6));
+	test(file.Read(23, buf, 6) == KErrNone);
+	test(buf.Length() == 3 && buf == KTestText().Right(3));
+	test(file.Read(27, buf, 6) == KErrNone);
+	test(buf.Length() == 0);
+
+	file.Close();
+	
+	test(fs.Delete(KTestFile) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileWrite()
+	{
+	_LIT(KTestFile, "c:\\symport_test_rfile_write");
+	_LIT8(KTestText, "abcdefghijklm");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	TBuf8<26> buf;
+	RFile file;
+	test(file.Replace(fs, KTestFile, 0) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf.Length() == 0);
+
+	// File position at the start
+	TInt pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+
+	test(file.Write(KTestText) == KErrNone); //13
+
+	// Check position updated
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 13);
+
+	test(file.Read(0, buf) == KErrNone && buf == KTestText);
+	test(file.Write(KTestText) == KErrNone); //26
+	test(file.Read(0, buf) == KErrNone && buf.Length() == 26 && buf.Left(13) == KTestText  && buf.Right(13) == KTestText);
+	file.Close();
+
+	// Test read after write
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Write(KTestText) == KErrNone);
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 13);
+	file.Close();
+
+	// Test write after read
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf.Length() == 26);
+	test(file.Write(KTestText) == KErrNone);
+	test(file.Read(26, buf) == KErrNone && buf.Length() == 13);
+	file.Close();
+	
+	test(file.Replace(fs, KTestFile, 0) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf.Length() == 0);
+	test(file.Write(KTestText, 6) == KErrNone); //6
+	test(file.Read(0, buf) == KErrNone && buf == KTestText().Left(6));
+	test(file.Write(KTestText, 6) == KErrNone); //12
+	test(file.Read(0, buf) == KErrNone && buf.Length() == 12 && buf.Left(6) == KTestText().Left(6)  && buf.Right(6) == KTestText().Left(6));
+	file.Close();
+	
+	// Test read after write
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Write(KTestText, 6) == KErrNone); //6
+	test(file.Read(buf) == KErrNone && buf.Length() == 6);
+	file.Close();
+
+	// Test write after read
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf.Length() == 12);
+	test(file.Write(KTestText, 6) == KErrNone);
+	test(file.Read(12, buf) == KErrNone && buf.Length() == 6);
+	file.Close();
+
+	test(file.Replace(fs, KTestFile, 0) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf.Length() == 0);
+	test(file.Write(3, KTestText) == KErrNone); //0+13=13
+	test(file.Read(0, buf) == KErrNone);
+	test(buf.Length() == 13);
+	test(buf == KTestText);
+	test(file.Write(7, KTestText) == KErrNone); //7+13=20
+	test(file.Read(0, buf) == KErrNone && buf.Length() == 20 && buf.Mid(7,13) == KTestText());
+	file.Close();
+
+	// Test read after write
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Write(0, KTestText) == KErrNone); //13
+	test(file.Read(buf) == KErrNone && buf.Length() == 7);
+	file.Close();
+
+	// Test write after read
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf.Length() == 20);
+	test(file.Write(10, KTestText) == KErrNone); //10+13=23
+	test(file.Read(0, buf) == KErrNone && buf.Length() == 23);
+	file.Close();
+
+	test(file.Replace(fs, KTestFile, 0) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf.Length() == 0);
+	test(file.Write(3, KTestText, 10) == KErrNone); //0+10=10
+	test(file.Read(0, buf) == KErrNone);
+	test(buf.Length() == 10 && buf == KTestText().Left(10));
+	test(file.Write(0, KTestText, 3) == KErrNone); //10
+	test(file.Read(0, buf) == KErrNone );
+	test(buf.Length() == 10);
+	test(buf.Left(3) == KTestText().Left(3));
+	file.Close();
+
+	// Test read after write
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Write(0, KTestText, 3) == KErrNone); //3
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 7);
+	file.Close();
+
+	// Test write after read
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Read(buf) == KErrNone && buf.Length() == 10);
+	test(file.Write(13, KTestText, 6) == KErrNone); //10+6=16
+	test(file.Read(0, buf) == KErrNone && buf.Length() == 16);
+	file.Close();
+	
+	test(fs.Delete(KTestFile) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileSeek()
+	{
+	_LIT(KTestFile, "c:\\symport_test_rfile_seek");
+	_LIT8(KTestText, "abcdefghijklmnopqrstuvwxyz");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	// Create the file
+	RFile file;
+	test(file.Replace(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Write(KTestText) == KErrNone);
+	
+	// ESeekAddress is invalid
+	TInt pos = 0;
+	test(file.Seek(ESeekAddress, pos) == KErrNotSupported);
+	
+	// Error on negative offset
+	pos = -999;
+	test(file.Seek(ESeekStart, pos) == KErrArgument);
+	
+	// Test you can get the file position
+	pos = 12;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	test(pos == 12);
+	TBuf8<26> buf;
+	test(file.Read(buf, 1) == KErrNone);
+	test(buf == _L8("m")); //13
+
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 13);
+	
+	// Move to the end of the file
+	pos = 30;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	test(pos == 30);
+	test(file.Size(pos) == KErrNone);
+	test(pos == 26);
+	
+	// Move back from the end
+	pos = -1;
+	test(file.Seek(ESeekEnd, pos) == KErrNone);
+	test(pos == 25);
+	test(file.Read(buf) == KErrNone);
+	test(buf == _L8("z"));
+
+	// Move past the end
+	pos = 10;
+	test(file.Seek(ESeekEnd, pos) == KErrNone);
+	test(pos == 26);
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 0);
+	
+	// Move before the start
+	pos = -30;
+	test(file.Seek(ESeekEnd, pos) == KErrNone);
+	test(pos == 0);
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 26);
+	
+	// Check seek to current
+	pos = 13;
+	test(file.Seek(ESeekStart, pos) == KErrNone);
+	test(file.Read(buf, 1) == KErrNone); //14
+	test(buf == _L8("n"));
+	pos = -13;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 1);
+	test(file.Read(buf, 1) == KErrNone); //2
+	test(buf == _L8("b"));
+
+	// Before the start
+	pos = -10;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+	test(file.Read(buf, 1) == KErrNone); //1
+	test(buf == _L8("a"));
+
+	// After the end
+	pos = 26;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 26);
+	test(file.Read(buf, 1) == KErrNone);
+	test(buf.Length() == 0);
+	
+	// Check current pos
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 26);
+
+	// And check you can go back
+	pos = -1;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(file.Read(buf, 1) == KErrNone);
+	test(buf == _L8("z"));
+	
+	file.Close();
+	test(fs.Delete(KTestFile) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileFlush()
+	{
+	_LIT(KTestFile, "c:\\symport_test_rfile_flush");
+	_LIT8(KTestText, "abcdefghijklmnopqrstuvwxyz");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	fs.Delete(KTestFile);
+	
+	// Create the file
+	RFile file;
+	test(file.Replace(fs, KTestFile, EFileWrite) == KErrNone);
+
+	// Check file pos
+	TInt pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+
+	test(file.Write(KTestText) == KErrNone);
+	
+	// Check file pos
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 26);
+
+	test(file.Flush() == KErrNone);
+
+	// Check file pos hasn't changed
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 26);
+
+	file.Close();
+	
+	test(fs.Delete(KTestFile) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileSize()
+	{
+	_LIT(KTestFile, "c:\\symport_test_rfile_flush");
+	_LIT8(KTestText, "abcdefghijklmnopqrstuvwxyz");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	fs.Delete(KTestFile);
+	
+	// Create the file
+	RFile file;
+	test(file.Replace(fs, KTestFile, EFileWrite) == KErrNone);
+
+	TInt size = 0;
+	test(file.Size(size) == KErrNone);
+	test(size == 0);
+	
+	// Check file pos
+	TInt pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+
+	test(file.Write(KTestText) == KErrNone);
+	
+	size = 0;
+	test(file.Size(size) == KErrNone);
+	test(size == 26);
+
+	// Check file pos
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 26);
+
+	file.Close();
+	
+	test(fs.Delete(KTestFile) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileSetSize()
+	{
+	_LIT(KTestFile, "c:\\symport_test_rfile_flush");
+	_LIT8(KTestText, "abcdefghijklmnopqrstuvwxyz");
+	
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	fs.Delete(KTestFile);
+	
+	// Create the file
+	RFile file;
+	test(file.Replace(fs, KTestFile, EFileWrite) == KErrNone);
+	
+	// Check file pos
+	TInt pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+
+	test(file.Write(KTestText) == KErrNone); //26
+
+	// Set the size to bigger
+	test(file.SetSize(30) == KErrNone);
+
+	// Check file pos is unchanged
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 26);
+
+	// Set the size to smaller
+	test(file.SetSize(20) == KErrNone);
+
+	// Check file pos is at the end
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 20);
+
+	file.Close();
+
+	// Open for reading	
+	test(file.Open(fs, KTestFile, 0) == KErrNone);
+
+	// Shouldn't be allowed to set the size
+	test(file.SetSize(10) == KErrAccessDenied);
+	
+	file.Close();
+	
+	test(fs.Delete(KTestFile) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileAtt()
+	{
+	// Connect to the file system
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	_LIT(KTestFile, "c:\\symport_test_rile_att.txt");	
+
+	// See if it works for normal files
+	TUint att;
+	RFile file;
+	test(file.Replace(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);
+	
+	// Check file pos is at the start
+	TInt pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+
+	test(file.Write(_L8("test")) == KErrNone);
+	test(file.Att(att) == KErrNone);
+	test(!(att&KEntryAttDir));
+
+	// Check file pos is correct
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 4);
+
+	// Check readonly flag
+	test(!(att&KEntryAttReadOnly));
+	test(file.SetAtt(KEntryAttReadOnly, 0) == KErrNone);
+	test(file.Att(att) == KErrNone && att&KEntryAttReadOnly);
+	
+	// Clear the flag
+	test(file.SetAtt(0, KEntryAttReadOnly) == KErrNone);
+	test(file.Att(att) == KErrNone);
+	test(!(att&KEntryAttReadOnly));
+	file.Close();
+	
+	// Delete the file
+	test(fs.Delete(KTestFile) == KErrNone);	
+	fs.Close();
+	}
+
+void testRFileModified()
+	{
+	// Connect to the file system
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	_LIT(KTestFile, "c:\\symport_test_rile_modified.txt");	
+
+	// See if it works for normal files
+	RFile file;
+	test(file.Replace(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);
+	
+	// Check file pos is at the start
+	TInt pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+
+	test(file.Write(_L8("test")) == KErrNone);
+	test(file.Flush() == KErrNone);
+
+	TTime then;
+	test(file.Modified(then) == KErrNone);
+	User::After(2000000);
+	
+	// Check file pos is correct
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 4);
+	
+	file.Close();
+	
+	test(file.Open(fs, KTestFile, EFileWrite) == KErrNone);
+	test(file.Write(_L8("test")) == KErrNone);
+	test(file.Flush() == KErrNone);
+	
+	TTime now;
+	test(file.Modified(now) == KErrNone);
+
+	TTimeIntervalSeconds sec;
+	test(now.SecondsFrom(then, sec) == KErrNone);
+	test(sec.Int() >= 1);
+	
+	file.Close();
+	
+	// Delete the file
+	test(fs.Delete(KTestFile) == KErrNone);	
+	fs.Close();
+	}
+
+void testRFileDrive()
+	{
+	// Connect to the file system
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	_LIT(KTestFile, "c:\\symport_test_rile_drive.txt");	
+
+	// See if it works for normal files
+	RFile file;
+	test(file.Replace(fs, KTestFile, EFileShareAny|EFileWrite) == KErrNone);
+	
+	TInt drive;
+	TDriveInfo info;
+	
+	test(file.Drive(drive, info) == KErrNone);
+	test(drive == EDriveC);
+	
+#ifdef __TOOLS2__
+	test(info.iType == EMediaHardDisk);
+	test(info.iBattery == EBatNotSupported);
+	test(info.iDriveAtt&(KDriveAttLocal|KDriveAttInternal));
+	test(info.iMediaAtt == 0);
+#endif
+
+	file.Close();
+	
+	// Delete the file
+	test(fs.Delete(KTestFile) == KErrNone);	
+	file.Close();
+	fs.Close();
+	}
+
+void testRFileRename()
+	{
+	// Connect to the file system
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	_LIT(KTestFile1, "c:\\symport_test_rile_rename_a.txt");	
+	_LIT(KTestFile2, "c:\\symport_test_rile_rename_b.txt");	
+	fs.Delete(KTestFile1);
+	fs.Delete(KTestFile2);
+	
+	// See if it works for normal files
+	RFile file;
+	test(file.Replace(fs, KTestFile1, EFileShareExclusive|EFileWrite) == KErrNone);
+	
+	// Check file pos is correct
+	TInt pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+	test(file.Write(_L8("test")) == KErrNone);
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 4);
+
+	test(file.Rename(KTestFile2) == KErrNone);
+	
+	// Check file pos is correct
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 4);
+	test(file.Write(_L8("test")) == KErrNone);
+	file.Close();
+
+	test(file.Open(fs, KTestFile2, EFileShareExclusive) == KErrNone);
+
+	// Check file pos is correct
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 0);
+	TBuf8<16> buf;
+	test(file.Read(buf) == KErrNone);
+	test(buf.Length() == 8);
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 8);
+
+	// Should fail because not opened for write
+	test(file.Rename(KTestFile1) == KErrAccessDenied);
+
+	// Check file pos is correct
+	pos = 0;
+	test(file.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 8);
+
+	// Check you can't write to the file
+	test(file.Write(_L8("test")) == KErrAccessDenied);
+	file.Close();
+	
+	// Recreate the first file
+	test(file.Replace(fs, KTestFile1, EFileShareExclusive|EFileWrite) == KErrNone);
+	file.Close();
+	
+	// Check error if renaming to existing file
+	test(file.Open(fs, KTestFile2, EFileShareExclusive) == KErrNone);	
+	test(file.Rename(KTestFile1) == KErrAccessDenied);
+	file.Close();
+	
+	// Cleanup
+	test(fs.Delete(KTestFile1) == KErrNone);
+	test(fs.Delete(KTestFile2) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileDuplicate()
+	{
+	// Connect to the file system
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	_LIT(KTestFile1, "c:\\symport_test_rile_duplicate.txt");	
+
+	RFile file1;
+	test(file1.Replace(fs, KTestFile1, EFileWrite) == KErrNone);
+	test(file1.Write(_L8("Test")) == KErrNone);
+	test(file1.Flush() == KErrNone);
+	
+	// Test you can duplicate the handle and read from it
+	RFile file2;
+	test(file2.Duplicate(file1) == KErrNone);
+	
+	// File position should match
+	TInt pos = 0;
+	test(file2.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 4);
+	
+	// Move back to the start
+	pos = 0;
+	test(file2.Seek(ESeekStart, pos) == KErrNone);
+	test(pos == 0);
+	
+	// Check you can read from the file
+	TBuf8<8> buf;
+	test(file2.Read(buf) == KErrNone);
+	test(buf.Length() == 4);
+
+	// Check you can write to the file
+	test(file2.Write(_L8("Test")) == KErrNone);
+
+	file1.Close();
+	file2.Close();
+	
+	// Now open readonly
+	test(file1.Open(fs, KTestFile1, 0) == KErrNone);
+	pos = 4;
+	test(file1.Seek(ESeekStart, pos) == KErrNone);
+	test(pos == 4);
+	
+	// Test you can duplicate the handle and read from it
+	test(file2.Duplicate(file1) == KErrNone);
+	
+	// File position should match
+	pos = 0;
+	test(file2.Seek(ESeekCurrent, pos) == KErrNone);
+	test(pos == 4);
+	
+	// Move back to the start
+	pos = 0;
+	test(file2.Seek(ESeekStart, pos) == KErrNone);
+	test(pos == 0);
+	
+	// Check you can read from the file
+	test(file2.Read(buf) == KErrNone);
+	test(buf.Length() == 8);
+
+	// Check you can't write to the file
+	test(file2.Write(_L8("Test")) == KErrAccessDenied);
+
+	file1.Close();
+	file2.Close();
+	
+	test(fs.Delete(KTestFile1) == KErrNone);
+	fs.Close();
+	}
+
+void testRFileName()
+	{
+	// Connect to the file system
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+	
+	_LIT(KTestFile1, "C:\\symport_test_rile_filename.txt");	
+
+	RFile file1;
+	test(file1.Replace(fs, KTestFile1, 0) == KErrNone);
+
+	TFileName name;
+	test(file1.Name(name) == KErrNone);
+	test(name == KTestFile1().Mid(3));
+	test(file1.FullName(name) == KErrNone);
+	test(name == KTestFile1);
+	file1.Close();
+	
+	test(fs.Delete(KTestFile1) == KErrNone);
+	fs.Close();
+	}
+
+void testRFs()
+	{	
+	test.Start(_L("Att"));
+	testAtt();
+	
+	test.Next(_L("SetAtt"));
+	testSetAtt();
+
+	test.Next(_L("Modified"));
+	testModified();
+
+	test.Next(_L("MkDir"));
+	testMkDir();
+
+	test.Next(_L("MkDirAll"));
+	testMkDirAll();
+	
+	test.Next(_L("RmDir"));
+	testRmDir();
+	
+	test.Next(_L("Parse"));
+	testParse();
+	
+	test.Next(_L("SessionPath"));
+	testSessionPath();
+	
+	test.Next(_L("SetSessionPath"));
+	testSetSessionPath();
+	
+	test.Next(_L("Delete"));
+	testDelete();
+	
+	test.Next(_L("VolumeIOParam"));
+#ifdef __TOOLS2__
+	testVolumeIOParam();
+#endif
+	
+	test.Next(_L("Entry"));
+	testEntry();
+
+	test.Next(_L("SetEntry"));
+	testSetEntry();
+	
+	test.Next(_L("SetErrorCondition"));
+#ifdef __TOOLS2__
+	testSetErrorCondition();
+#endif
+	
+	test.Next(_L("CharToDrive"));
+	testCharToDrive();
+
+	test.Next(_L("DriveToChar"));
+	testDriveToChar();
+
+	test.Next(_L("IsValidDrive"));
+	testIsValidDrive();
+
+	test.Next(_L("Drive"));
+	testDrive();
+
+	test.Next(_L("GetSystemDrive"));
+	testGetSystemDrive();
+
+	test.Next(_L("Replace"));
+	testReplace();
+
+	test.Next(_L("Rename"));
+	testRename();
+
+	test.End();
+	}
+
+void testTParse()
+	{
+	test.Start(_L("Test all TParse methods"));
+	TestTParse1();
+
+	test.Next(_L("Test multiple PopDirs"));
+	TestTParse2();
+	
+	test.Next(_L("Test conflicting default drive letters"));
+	TestTParse3();
+
+	test.Next(_L("Test conflicting relative drive letters"));
+	TestTParse4();
+	
+	test.Next(_L("Test errors returned by illegal paths"));
+	TestTParse5();
+	
+	test.Next(_L("Test AddDir"));
+	TestTParse6();
+	
+	test.Next(_L("Test TParsePtr"));
+	TestTParse7();
+	
+	test.Next(_L("Test TParsePtrC"));
+	TestTParse8();
+
+	test.Next(_L("Test names with leading spaces"));
+	TestTParse9();
+	
+	test.Next(_L("Test a Path > 256 chars"));
+	TestTParse10();
+	
+	test.End();
+	}
+
+void testTFileText()
+	{
+	test.Start(_L("Test file text"));
+	testTFileTextApi();
+	
+	test.Next(_L("Test FileText last record has no terminator"));
+	testTFileTextEndRecord();
+
+	test.End();
+	}
+
+void testRFile()
+	{
+	test.Start(_L("Open"));
+	testRFileOpen();
+	
+	test.Next(_L("Create"));
+	testRFileCreate();
+	
+	test.Next(_L("Replace"));
+	testRFileReplace();
+	
+	test.Next(_L("Temp"));
+	testRFileTemp();
+	
+	test.Next(_L("Read"));	
+	testRFileRead();
+	
+	test.Next(_L("Write"));
+	testRFileWrite();
+	
+	test.Next(_L("Seek"));
+	testRFileSeek();
+	
+	test.Next(_L("Flush"));
+	testRFileFlush();
+	
+	test.Next(_L("Size"));
+	testRFileSize();
+	
+	test.Next(_L("SetSize"));
+	testRFileSetSize();
+	
+	test.Next(_L("Att"));
+	testRFileAtt();
+	
+	test.Next(_L("Modified"));
+	testRFileModified();
+	
+	test.Next(_L("Drive"));
+	testRFileDrive();
+	
+	test.Next(_L("Rename"));
+	testRFileRename();
+	
+	test.Next(_L("Duplicate"));
+	testRFileDuplicate();
+	
+	test.Next(_L("Name"));
+	testRFileName();
+	
+	test.End();
+	}
+
+// This following isn't relevant to WINSCW
+#ifdef __TOOLS2__
+void testSpecialFilenameProcessing()
+	{
+	// Connect to the file system
+	RFs fs;
+	test(fs.Connect() == KErrNone);
+
+	fs.RmDir(_L("c:\\testMisc\\epoc32\\test1\\"));
+	fs.RmDir(_L("c:\\testMisc\\epoc32\\test2\\"));
+	fs.RmDir(_L("c:\\testMisc\\epoc32\\"));
+	fs.RmDir(_L("c:\\testMisc\\"));
+
+	TUint att;
+	_LIT(KCDriveTest1, "c:\\testMisc\\epoc32\\test1\\");
+	test(fs.MkDirAll(KCDriveTest1) == KErrNone);
+	test(fs.Att(KCDriveTest1, att) == KErrNone);
+	
+	struct stat sb;
+#ifdef _WIN32
+	test(stat("c:\\testMisc\\epoc32\\test1", &sb) == 0);
+#else
+	// Get home
+	char* env = getenv("HOME");
+	test(env != NULL);
+	char home[0x100];
+	strcpy(home, env);
+	
+	// Check it's replaced c: with HOME
+	char testpath[0x100];
+	strcpy(testpath, home);
+	strcat(testpath, "/testmisc/epoc32/test1");
+	test(stat(testpath, &sb) == 0);
+#endif
+		
+#ifdef _WIN32
+	static char *env = "EPOCROOT=\\";
+	test(putenv(env) == 0);
+#else
+	test(setenv("EPOCROOT", home, 1) == 0);
+#endif
+	
+	_LIT(KEpocRootTest, "\\epoc32\\winscw\\c\\testMisc\\test1\\");
+	test(fs.MkDirAll(KEpocRootTest) == KErrNone);
+	test(fs.Att(KEpocRootTest, att) == KErrNone);
+
+#ifdef _WIN32
+	test(stat("\\epoc32\\winscw\\c\\testMisc\\test1", &sb) == 0);
+#else
+	// Check it's replaced \epoc32 with $(EPOCROOT)epoc32
+	strcpy(testpath, home);
+	strcat(testpath, "/epoc32/winscw/c/testmisc/test1");
+	test(stat(testpath, &sb) == 0);
+#endif
+
+	test(fs.RmDir(KEpocRootTest) == KErrNone);
+	test(fs.RmDir(_L("\\epoc32\\winscw\\c\\testMisc\\")) == KErrNone);
+	
+	// Now set EPOCROOT to something a bit more complicated
+#ifdef _WIN32
+	env = "EPOCROOT=c:\\testMisc";
+	test(putenv(env) == 0);
+#else
+	strcpy(testpath, home);
+	strcat(testpath, "/testmisc/");
+	test(setenv("EPOCROOT", testpath, 1) == 0);
+#endif
+
+	_LIT(KCDriveTest2, "\\epoc32\\test2\\");
+	test(fs.MkDirAll(KCDriveTest2) == KErrNone);
+	test(fs.Att(_L("\\epoc32\\test1\\"),att) == KErrNone);
+	test(fs.Att(_L("\\epoc32\\test2\\"),att) == KErrNone);
+
+#ifdef _WIN32
+	test(stat("c:\\testMisc\\epoc32\\test2", &sb) == 0);
+#else
+	strcpy(testpath, home);
+	strcat(testpath, "/testmisc/epoc32/test2");
+	test(stat(testpath, &sb) == 0);
+#endif
+
+#ifdef _WIN32
+	env = "EPOCROOT=\\";
+	test(putenv(env) == 0);
+#else
+	test(setenv("EPOCROOT", home, 1) == 0);
+#endif
+	
+	test(fs.RmDir(_L("c:\\testMisc\\epoc32\\test1\\")) == KErrNone);
+	test(fs.RmDir(_L("c:\\testMisc\\epoc32\\test2\\")) == KErrNone);
+	test(fs.RmDir(_L("c:\\testMisc\\epoc32\\")) == KErrNone);
+	test(fs.RmDir(_L("c:\\testMisc\\")) == KErrNone);
+	
+	fs.Close();
+	}
+
+#ifdef USING_SYMPORT_DLL
+IMPORT_C TVersion SymPortVersion();
+void testVersion()
+	{
+	TVersion ver(SymPortVersion());
+	test(ver.iMajor >= 1);
+
+	TPtrC name(ver.Name());
+	test.Printf(_L("Symport Version: %S\n"), &name);
+	}
+#endif
+#endif
+
+void doMainL()
+	{
+	test.Start(_L("RFs"));
+	testRFs();
+	
+	test.Next(_L("TParse"));
+	testTParse();
+
+	test.Next(_L("TFileText"));
+	testTFileText();
+	
+	test.Next(_L("RFile"));
+	testRFile();
+
+	test.Next(_L("Misc"));
+#ifdef __TOOLS2__
+	testSpecialFilenameProcessing();
+#ifdef USING_SYMPORT_DLL
+	testVersion();
+#endif
+#endif
+
+	test.End();	
+	}
+int E32Main()
+	{
+	__UHEAP_MARK;
+	CTrapCleanup* theCleanup = CTrapCleanup::New();
+	TRAPD(ret, doMainL());
+	test(ret == KErrNone);
+	test.Close();
+	delete theCleanup;
+	__UHEAP_MARKEND;
+	return ret;
+	}