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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #define __E32TEST_EXTENSION__

    17 

    18 #include <f32file.h>

    19 #include <e32test.h>

    20 #include <e32svr.h>

    21 #include "t_server.h"

    22 #include "t_chlffs.h"

    23 #include "fs_utils.h"

    24 

    25 #include "f32_test_utils.h"

    26 

    27 using namespace F32_Test_Utils;

    28 

    29 RTest test(_L("T_FILE"));

    30 

    31 TBool gShortFileNamesSupported = EFalse;

    32 

    33 static TBuf8<1500> gBuf;

    34 

    35 TInt gDriveNum = -1;

    36 

    37 static void testShare()

    38 //

    39 // Test file sharing.

    40 //

    41 	{

    42 

    43 	test.Start(_L("Test exclusive sharing"));

    44 	MakeFile(_L("TESTER"));

    45 

    46 /*

    47 	Extra code to answer a question about a potential WINS bug.  WINS Elocal returns

    48 	KErrAccessDenied to the write operation but EFat returns

    49 	KErrNone...

    50 

    51 	RFile f1;

    52 	TInt r=f1.Open(TheFs,_L("TESTER"),EFileRead|EFileShareAny);

    53 	test(r==KErrNone);

    54 	RFile f2;

    55 	r=f2.Open(TheFs,_L("TESTER"),EFileWrite|EFileShareAny);

    56 	test(r==KErrNone);

    57 

    58 	r=f2.Write(_L("0"));

    59 	test.Printf(_L("returned %d"),r);

    60 

    61 	f1.Close();

    62 	f2.Close();

    63 

    64 	r=TheFs.Delete(_L("TESTER"));

    65 	test(r==KErrNone);

    66 */

    67 

    68 	RFile f1;

    69 	TInt r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

    70 	test(r==KErrNone);

    71 	RFile f2;

    72 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

    73 	test(r==KErrInUse);

    74 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

    75 	test(r==KErrInUse);

    76 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareAny);

    77 	test(r==KErrInUse);

    78 	f1.Close();

    79 	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareExclusive);

    80 	test(r==KErrNone);

    81 	f1.Close();

    82 

    83 	test.Next(_L("Test readers only sharing"));

    84 	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareReadersOnly);

    85 	test(r==KErrArgument);

    86 	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

    87 	test(r==KErrNone);

    88 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

    89 	test(r==KErrInUse);

    90 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareAny);

    91 	test(r==KErrInUse);

    92 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareReadersOnly);

    93 	test(r==KErrArgument);

    94 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

    95 	test(r==KErrNone);

    96 	f1.Close();

    97 	f2.Close();

    98 

    99 	test.Next(_L("Test any sharing"));

   100 	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareAny);

   101 	test(r==KErrNone);

   102 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

   103 	test(r==KErrInUse);

   104 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

   105 	test(r==KErrInUse);

   106 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareAny);

   107 	test(r==KErrNone);

   108 	f1.Close();

   109 	f2.Close();

   110 

   111 	test.End();

   112 	}

   113 

   114 static void testChangeMode()

   115 //

   116 // Test changing the share mode of a file between EFileShareReadersOnly <-> EFileShareExclusive

   117 //

   118 	{

   119 

   120 	test.Start(_L("Test change mode"));

   121 	RFile f1;

   122 	RFile f2;

   123 	TInt r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

   124 	test(r==KErrNone); // Opened exclusive

   125 	r=f1.ChangeMode(EFileShareReadersOnly);

   126 	test(r==KErrNone); // Change to readers only

   127 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

   128 	test(r==KErrNone); // Open as reader

   129 	r=f1.ChangeMode(EFileShareExclusive);

   130 	test(r==KErrAccessDenied); // Change back to exclusive fails

   131 	r=f2.ChangeMode(EFileShareExclusive);

   132 	test(r==KErrAccessDenied); // Change to exclusive fails

   133 	f1.Close(); // Close other reader

   134 	r=f2.ChangeMode(EFileShareExclusive);

   135 	test(r==KErrNone); // Change to exclusive succeeds.

   136 	f2.Close();

   137 

   138 	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

   139 	test(r==KErrNone); // Opened readers only

   140 	r=f1.ChangeMode(EFileShareExclusive);

   141 	test(r==KErrNone); // Change to exclusive

   142 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

   143 	test(r==KErrInUse); // Open as reader fails

   144 	r=f1.ChangeMode(EFileShareReadersOnly);

   145 	test(r==KErrNone); // Change to readers only

   146 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

   147 	test(r==KErrNone); // Open as reader

   148 	r=f1.ChangeMode(EFileShareExclusive);

   149 	test(r==KErrAccessDenied); // Change back to exclusive fails

   150 	r=f2.ChangeMode(EFileShareExclusive);

   151 	test(r==KErrAccessDenied); // Change to exclusive fails

   152 	f1.Close(); // Close other reader

   153 	r=f2.ChangeMode(EFileShareExclusive);

   154 	test(r==KErrNone); // Change to exclusive succeeds.

   155 	f2.Close();

   156 

   157 	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite|EFileShareExclusive);

   158 	test(r==KErrNone); // Opened exclusive for writing

   159 	r=f1.ChangeMode(EFileShareReadersOnly);

   160 	test(r==KErrAccessDenied); // Change to readers fails

   161 	r=f1.ChangeMode(EFileShareExclusive);

   162 	test(r==KErrNone); // No change ok

   163 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

   164 	test(r==KErrInUse); // Open as reader fails

   165 	f1.Close();

   166 

   167 	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareAny);

   168 	test(r==KErrNone); // Opened share any

   169 	r=f1.ChangeMode(EFileShareExclusive);

   170 	test(r==KErrAccessDenied); // Change to exclusive fails

   171 	r=f1.ChangeMode(EFileShareReadersOnly);

   172 	test(r==KErrAccessDenied); // Change to readers only fails

   173 	f1.Close();

   174 

   175 	r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareExclusive);

   176 	test(r==KErrNone); // Opened exclusive

   177 	r=f1.ChangeMode(EFileShareAny);

   178 	test(r==KErrArgument); // Change to share any fails KErrArgument

   179 	r=f1.ChangeMode((TFileMode)42);

   180 	test(r==KErrArgument); // Change to random value fails

   181 	f1.Close();

   182 	test.End();

   183 	}

   184 

   185 static void testReadFile()

   186 //

   187 // Test read file handling.

   188 //

   189 	{

   190 

   191 	test.Start(_L("Test read file"));

   192 	RFile f,ZFile;

   193 	TInt r=f.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText);

   194 	test(r==KErrNone);

   195 	TFileName fn = _L("Z:\\TEST\\T_FILE.CPP");

   196 	fn[0] = gExeFileName[0];

   197 	r=ZFile.Open(TheFs,fn,EFileStreamText);

   198 	test(r==KErrNone);

   199 

   200 	test.Next(_L("Read file"));

   201 	TBuf8<0x100> a,b;

   202 	FOREVER

   203 		{

   204 		r=f.Read(b);

   205 		test(r==KErrNone);

   206 		r=ZFile.Read(a);

   207 		test(r==KErrNone);

   208 		test(a==b);

   209 		if (b.Length()<b.MaxLength())

   210 			break;

   211 		}

   212 	b.SetLength(10);

   213 	r=f.Read(b);

   214 	test(r==KErrNone);

   215 	test(b.Length()==0);

   216 	f.Close();

   217 	ZFile.Close();

   218 

   219 	test.Next(_L("Read way beyond the end of the file"));

   220 	r=f.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText);

   221 	test(r==KErrNone);

   222 	r=f.Read(3000000,gBuf);

   223 	test(r==KErrNone);

   224 	f.Close();

   225 

   226 	test.Next(_L("Write way beyond the end of the file"));

   227 	r=f.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileWrite);

   228 	test(r==KErrNone);

   229 	gBuf.SetLength(10);

   230 	r=f.Write(3000000,gBuf);

   231 	test(r==KErrNone);

   232 	f.Close();

   233 	test.End();

   234 	}

   235 

   236 static void testMultipleReadFile()

   237 //

   238 // Test multiple read file handling.

   239 //

   240 	{

   241 

   242 	test.Start(_L("Test multiple read file"));

   243 	RFile f1;

   244 	TInt r=f1.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

   245 	test(r==KErrNone);

   246 	RFile f2;

   247 	r=f2.Open(TheFs,_L("T_FILE.CPP"),EFileStreamText|EFileShareReadersOnly);

   248 	test(r==KErrNone);

   249 

   250 	test.Next(_L("Read file"));

   251 	FOREVER

   252 		{

   253 		TBuf8<0x100> b1;

   254 		r=f1.Read(b1);

   255 		test(r==KErrNone);

   256 		TBuf8<0x100> b2;

   257 		r=f2.Read(b2);

   258 		test(r==KErrNone);

   259 		test(b1==b2);

   260 		if (b1.Length()<b1.MaxLength())

   261 			break;

   262 		}

   263 

   264 	test.Next(_L("Close file"));

   265 	f1.Close();

   266 	f2.Close();

   267 

   268 	test.End();

   269 	}

   270 

   271 static void testWriteFile()

   272 //

   273 // Test write file handling.

   274 //

   275 	{

   276 	test.Start(_L("Test write file"));

   277 	RFile file;

   278 	TFileName fn = _L("File.File");

   279 	TBuf8<16> testData=_L8("testData");

   280 

   281 	// write test 1

   282 	TInt r=file.Replace(TheFs,fn,EFileStreamText);

   283 	test(r==KErrNone);

   284 

   285 	test.Next(_L("Write file"));

   286 

   287 	r=file.Write(testData);

   288 	test(r==KErrNone);

   289 

   290 	file.Close();

   291 

   292 	// test write modes

   293 	// test writing with EFileRead

   294 	r=file.Open(TheFs,fn,EFileStreamText|EFileRead);

   295 	test(r==KErrNone);

   296 

   297 	test.Next(_L("Write file"));

   298 	r=file.Write(testData);

   299 	test(r==KErrAccessDenied);

   300 	file.Close();

   301 

   302 	// test writing with EFileWrite

   303 	r=file.Open(TheFs,fn,EFileStreamText|EFileWrite);

   304 	test(r==KErrNone);

   305 

   306 	test.Next(_L("Write file"));

   307 	r=file.Write(testData);

   308 	test(r==KErrNone);

   309 	file.Close();

   310 

   311 	// test writing with share mode EFileShareExclusive

   312 	r=file.Open(TheFs,fn,EFileStreamText|EFileWrite|EFileShareExclusive);

   313 	test(r==KErrNone);

   314 

   315 	test.Next(_L("Write file"));

   316 	r=file.Write(testData);

   317 	test(r==KErrNone);

   318 	file.Close();

   319 

   320 	// test writing with share mode EFileShareReadersOnly (fails with KErrArgument)

   321 	r=file.Open(TheFs,fn,EFileStreamText|EFileWrite|EFileShareReadersOnly);

   322 	test(r==KErrArgument);

   323 

   324 	// test writing with share mode EFileShareReadersOrWriters

   325 	r=file.Open(TheFs,fn,EFileStreamText|EFileWrite|EFileShareReadersOrWriters);

   326 	test(r==KErrNone);

   327 

   328 	test.Next(_L("Write file"));

   329 	r=file.Write(testData);

   330 	test(r==KErrNone);

   331 	file.Close();

   332 

   333 	// test writing with share mode EFileShareAny

   334 	r=file.Open(TheFs,fn,EFileStreamText|EFileWrite|EFileShareAny);

   335 	test(r==KErrNone);

   336 

   337 	test.Next(_L("Write file"));

   338 	r=file.Write(testData);

   339 	test(r==KErrNone);

   340 	file.Close();

   341 

   342 	// tidy up

   343 	r=TheFs.Delete(fn);

   344 	test(r==KErrNone);

   345 

   346 	test.End();

   347 	}

   348 

   349 static void CopyFileToTestDirectory()

   350 //

   351 // Make a copy of the file in ram

   352 //

   353 	{

   354 

   355 	TFileName fn = _L("Z:\\TEST\\T_FILE.CPP");

   356 	fn[0] = gExeFileName[0];

   357 	TParse f;

   358 	TInt r;

   359 	r=TheFs.Parse(fn,f);

   360 	test(r==KErrNone);

   361 	TParse fCopy;

   362 	r=TheFs.Parse(f.NameAndExt(),fCopy);

   363 	test(r==KErrNone);

   364 

   365 	RFile f1;

   366 	r=f1.Open(TheFs,f.FullName(),EFileStreamText|EFileShareReadersOnly);

   367 	test(r==KErrNone);

   368 	RFile f2;

   369 	r=f2.Replace(TheFs,fCopy.FullName(),EFileWrite);

   370 	test(r==KErrNone);

   371 	TBuf8<512> copyBuf;

   372 	TInt rem;

   373 	r=f1.Size(rem);

   374 	test(r==KErrNone);

   375 	TInt pos=0;

   376 	while (rem)

   377 		{

   378 		TInt s=Min(rem,copyBuf.MaxSize());

   379 		r=f1.Read(pos,copyBuf,s);

   380 		test(r==KErrNone);

   381 		test(copyBuf.Length()==s);

   382 		r=f2.Write(pos,copyBuf,s);

   383 		test(r==KErrNone);

   384 		pos+=s;

   385 		rem-=s;

   386 		}

   387 	f1.Close();

   388 	f2.Close();

   389 	}

   390 

   391 static void testFileText()

   392 //

   393 // Test TFileText class methods

   394 //

   395 	{

   396 

   397 	test.Next(_L("Test file text"));

   398 	TPtrC record[5];

   399 	record[0].Set(_L("First record"));

   400 	record[1].Set(_L("Second record"));

   401 	record[2].Set(_L("Third record"));

   402 	record[3].Set(_L("Fourth record"));

   403 	record[4].Set(_L("Fifth record"));

   404 

   405 	RFile f;

   406 	TInt r=f.Replace(TheFs,_L("TEXTFILE.TXT"),0);

   407 	test(r==KErrNone);

   408 	TFileText textFile;

   409 	textFile.Set(f);

   410 	TInt i=0;

   411 	for (i=0;i<5;i++)

   412 		{

   413 		r=textFile.Write(record[i]);

   414 		test(r==KErrNone);

   415 		}

   416 	r=textFile.Seek(ESeekStart);

   417 	test(r==KErrNone);

   418 	TBuf<16> recBuf;

   419 	for(i=0;i<5;i++)

   420 		{

   421 		r=textFile.Read(recBuf);

   422 		test(r==KErrNone);

   423 		test(recBuf==record[i]);

   424 		}

   425 	r=textFile.Read(recBuf);

   426 	test(r==KErrEof);

   427 	test(recBuf.Length()==0);

   428 	f.Close();

   429 

   430 	test.Next(_L("Test dosfile terminator"));

   431 	TPtrC8 trecord[7];

   432 	TPtrC tTextrecord[7];

   433 	tTextrecord[0].Set(_L("First record\r\n"));

   434 	tTextrecord[1].Set(_L("Second record\r\n"));

   435 	tTextrecord[2].Set(_L("Third record\r\n"));

   436 	tTextrecord[3].Set(_L("Fourth record\r\n"));

   437 	tTextrecord[4].Set(_L("Fifth record\r\n"));

   438 	tTextrecord[5].Set(_L("Sixth record\n\r"));

   439 	tTextrecord[6].Set(_L("Seventh record\n"));

   440 	trecord[0].Set((TUint8*)tTextrecord[0].Ptr(),tTextrecord[0].Length()*sizeof(TText));

   441 	trecord[1].Set((TUint8*)tTextrecord[1].Ptr(),tTextrecord[1].Length()*sizeof(TText));

   442 	trecord[2].Set((TUint8*)tTextrecord[2].Ptr(),tTextrecord[2].Length()*sizeof(TText));

   443 	trecord[3].Set((TUint8*)tTextrecord[3].Ptr(),tTextrecord[3].Length()*sizeof(TText));

   444 	trecord[4].Set((TUint8*)tTextrecord[4].Ptr(),tTextrecord[4].Length()*sizeof(TText));

   445 	trecord[5].Set((TUint8*)tTextrecord[5].Ptr(),tTextrecord[5].Length()*sizeof(TText));

   446 	trecord[6].Set((TUint8*)tTextrecord[6].Ptr(),tTextrecord[6].Length()*sizeof(TText));

   447 	r=f.Replace(TheFs,_L("TEXTFILE.TXT"),0);

   448 	test(r==KErrNone);

   449 	for(i=0;i<7;i++)

   450 		{

   451 		TBuf8<256> buf;

   452 		buf.Copy(trecord[i]);

   453 		r=f.Write(buf);

   454 		test(r==KErrNone);

   455 		}

   456 	textFile.Set(f);

   457 	textFile.Seek(ESeekStart);

   458 	for(i=0;i<5;i++)

   459 		{

   460 		r=textFile.Read(recBuf);

   461 		test(r==KErrNone);

   462 		test(recBuf==record[i]);

   463 		}

   464 	r=textFile.Read(recBuf);

   465 	test(r==KErrNone);

   466 	test(recBuf==_L("Sixth record"));

   467 	r=textFile.Read(recBuf);

   468 	test(r==KErrNone);

   469 	test(recBuf==_L("\rSeventh record"));

   470 	r=textFile.Read(recBuf);

   471 	test(r==KErrEof);

   472 	test(recBuf.Length()==0);

   473 	f.Close();

   474 

   475 	test.Next(_L("Test read with bufferSize == dataSize"));

   476 	r=f.Replace(TheFs,_L("TEXTFILE.TXT"),0);

   477 	test(r==KErrNone);

   478 	record[0].Set(_L("1234567890123456"));

   479 //	trecord[0].Set(_L8("1234567890123456\r\n"));

   480 //	trecord[1].Set(_L8("1234567890123456\n"));

   481 

   482 	TPtrC tmpTextrecord;

   483 	tmpTextrecord.Set(_L("1234567890123456\r\n"));

   484 	trecord[0].Set((TUint8*)tmpTextrecord.Ptr(),tmpTextrecord.Length()*sizeof(TText));

   485 

   486 	tmpTextrecord.Set(_L("1234567890123456\n"));

   487 	trecord[1].Set((TUint8*)tmpTextrecord.Ptr(),tmpTextrecord.Length()*sizeof(TText));

   488 

   489 	for (i=0;i<2;i++)

   490 		{

   491 		r=f.Write(trecord[i]);

   492 		test(r==KErrNone);

   493 		}

   494 	textFile.Set(f);

   495 	textFile.Seek(ESeekStart);

   496 	for(i=0;i<2;i++)

   497 		{

   498 		r=textFile.Read(recBuf);

   499 		test(r==KErrNone);

   500 		test(recBuf==record[0]);

   501 		}

   502 	r=textFile.Read(recBuf);

   503 	test(r==KErrEof);

   504 	test(recBuf.Length()==0);

   505 	f.Close();

   506 

   507 	test.Next(_L("Read into a buffer < recordSize"));

   508 	TBuf<8> smallBuf;

   509 	r=f.Open(TheFs,_L("TEXTFILE.txt"),0);

   510 	test(r==KErrNone);

   511 	textFile.Set(f);

   512 	for(i=0;i<2;i++)

   513 		{

   514 		r=textFile.Read(smallBuf);

   515 		test(r==KErrTooBig);

   516 		test(smallBuf==_L("12345678"));

   517 		}

   518 	f.Close();

   519 

   520 	test.Next(_L("Nasty cases: 1) \\r \\n split over buffer boundary"));

   521 	r=f.Replace(TheFs,_L("TEXTFILE.txt"),0);

   522 	test(r==KErrNone);

   523 	HBufC* largeRecord=HBufC::NewL(600);

   524 	largeRecord->Des().SetLength(250);

   525 	largeRecord->Des().Fill('A');

   526 	largeRecord->Des()[249]='\n';

   527 	TPtrC8 bufPtr;

   528 	bufPtr.Set((TUint8*)largeRecord->Ptr(),largeRecord->Size()); // Size() returns length in bytes

   529 	r=f.Write(bufPtr);

   530 	test(r==KErrNone);

   531 	TBuf<16> boundaryBuf=_L("12345\r\n");

   532 	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());

   533 	r=f.Write(bufPtr);

   534 	test(r==KErrNone);

   535 	r=f.Write(trecord[0]);

   536 	test(r==KErrNone);

   537 

   538 	textFile.Set(f);

   539 	textFile.Seek(ESeekStart);

   540 	r=textFile.Read(recBuf);

   541 	test(r==KErrTooBig);

   542 	test(recBuf==_L("AAAAAAAAAAAAAAAA"));

   543 	r=textFile.Read(recBuf);

   544 	test(r==KErrNone);

   545 	test(recBuf==_L("12345"));

   546 	r=textFile.Read(recBuf);

   547 	test(r==KErrNone);

   548 	test(recBuf==record[0]);

   549 	f.Close();

   550 

   551 	test.Next(_L("Nasty cases: 2) \\r on buffer boundary"));

   552 	r=f.Replace(TheFs,_L("TEXTFILE.txt"),0);

   553 	test(r==KErrNone);

   554 	largeRecord->Des().SetLength(250);

   555 	largeRecord->Des().Fill('A');

   556 	largeRecord->Des()[249]='\n';

   557 	bufPtr.Set((TUint8*)largeRecord->Ptr(),largeRecord->Size());

   558 	r=f.Write(bufPtr);

   559 	test(r==KErrNone);

   560 	boundaryBuf=_L("12345\rxyz\n");

   561 	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());

   562 	r=f.Write(bufPtr);

   563 	test(r==KErrNone);

   564 	r=f.Write(trecord[0]);

   565 	test(r==KErrNone);

   566 

   567 	textFile.Set(f);

   568 	textFile.Seek(ESeekStart);

   569 	r=textFile.Read(recBuf);

   570 	test(r==KErrTooBig);

   571 	test(recBuf==_L("AAAAAAAAAAAAAAAA"));

   572 	r=textFile.Read(recBuf);

   573 	test(r==KErrNone);

   574 	test(recBuf==_L("12345\rxyz"));

   575 	r=textFile.Read(recBuf);

   576 	test(r==KErrNone);

   577 	test(recBuf==record[0]);

   578 	f.Close();

   579 

   580 	test.Next(_L("Nasty cases: 3) record size > buffer size"));

   581 	r=f.Replace(TheFs,_L("TEXTFILE.txt"),0);

   582 	test(r==KErrNone);

   583 	largeRecord->Des().SetLength(600);

   584 	largeRecord->Des().Fill('Z');

   585 	largeRecord->Des()[511]='\r';

   586 	largeRecord->Des()[599]='\n';

   587 	bufPtr.Set((TUint8*)largeRecord->Ptr(),largeRecord->Size());

   588 	r=f.Write(bufPtr);

   589 	test(r==KErrNone);

   590 	boundaryBuf=_L("12345\rxyz\n");

   591 	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());

   592 	r=f.Write(bufPtr);

   593 	test(r==KErrNone);

   594 	r=f.Write(trecord[0]);

   595 	test(r==KErrNone);

   596 

   597 	textFile.Set(f);

   598 	textFile.Seek(ESeekStart);

   599 	r=textFile.Read(recBuf);

   600 	test(r==KErrTooBig);

   601 	test(recBuf==_L("ZZZZZZZZZZZZZZZZ"));

   602 	r=textFile.Read(recBuf);

   603 	test(r==KErrNone);

   604 	test(recBuf==_L("12345\rxyz"));

   605 	r=textFile.Read(recBuf);

   606 	test(r==KErrNone);

   607 	test(recBuf==record[0]);

   608 

   609 	TBuf<601> bigBuf;

   610 	TPtrC largePtr((TText*)largeRecord->Ptr(),(largeRecord->Length()-1));

   611 	textFile.Seek(ESeekStart);

   612 	r=textFile.Read(bigBuf);

   613 	test(r==KErrNone);

   614 	test(bigBuf==largePtr);

   615 	r=textFile.Read(recBuf);

   616 	test(r==KErrNone);

   617 	test(recBuf==_L("12345\rxyz"));

   618 	r=textFile.Read(recBuf);

   619 	test(r==KErrNone);

   620 	test(recBuf==record[0]);

   621 	f.Close();

   622 

   623 	User::Free(largeRecord);

   624 	}

   625 

   626 static void testFileTextEndRecord()

   627 //

   628 // Test terminating record

   629 //

   630 	{

   631 

   632 	test.Next(_L("Test FileText last record has no terminator"));

   633 	RFile f;

   634 	TInt r=f.Replace(TheFs,_L("TextFile"),0);

   635 	test(r==KErrNone);

   636 	TPtrC8 bufPtr;

   637 	TBuf<16>boundaryBuf=_L("Record1\n");

   638 	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());

   639 	r=f.Write(bufPtr);

   640 	test(r==KErrNone);

   641 	boundaryBuf=_L("Record2\n");

   642 	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());

   643 	r=f.Write(bufPtr);

   644 	test(r==KErrNone);

   645 	boundaryBuf=_L("Record3\n");

   646 	bufPtr.Set((TUint8*)boundaryBuf.Ptr(),boundaryBuf.Size());

   647 	r=f.Write(bufPtr);

   648 	test(r==KErrNone);

   649 

   650 	TFileText fText;

   651 	fText.Set(f);

   652 	r=fText.Seek(ESeekStart);

   653 	test(r==KErrNone);

   654 	TBuf<32> recBuf;

   655 	r=fText.Read(recBuf);

   656 	test(r==KErrNone);

   657 	test(recBuf.MatchF(_L("record1"))!=KErrNotFound);

   658 	r=fText.Read(recBuf);

   659 	test(r==KErrNone);

   660 	test(recBuf.MatchF(_L("record2"))!=KErrNotFound);

   661 	r=fText.Read(recBuf);

   662 	test(r==KErrNone);

   663 	test(recBuf.MatchF(_L("record3"))!=KErrNotFound);

   664 	r=fText.Read(recBuf);

   665 	test(r==KErrEof);

   666 	test(recBuf.Length()==0);

   667 	f.Close();

   668 

   669 	TBuf<0x100> bigBuf(0x100);

   670 	bigBuf.Fill('A');

   671 	r=f.Replace(TheFs,_L("TextFile"),0);

   672 	test(r==KErrNone);

   673 

   674     bufPtr.Set((TUint8*)bigBuf.Ptr(),bigBuf.Size());

   675 	r=f.Write(bufPtr);

   676 	test(r==KErrNone);

   677 

   678 	fText.Set(f);

   679 	r=fText.Seek(ESeekStart);

   680 	test(r==KErrNone);

   681 	bigBuf.SetLength(0);

   682 	r=fText.Read(bigBuf);

   683 	test.Printf(_L("fText.Read returns %d\n"),r);

   684 	test(r==KErrNone);

   685 	test.Printf(_L("BigBuf.Length()==%d\n"),bigBuf.Length());

   686 	test(bigBuf.Length()==0x100);

   687 	r=fText.Read(bigBuf);

   688 	test(r==KErrEof);

   689 	test(bigBuf.Length()==0);

   690 	f.Close();

   691 	}

   692 

   693 static void testFileNames()

   694 //

   695 // Test file names

   696 //

   697 	{

   698 

   699 	test.Next(_L("Test temp filenames specify drive"));

   700 	TFileName tempFileName;

   701 	RFile f;

   702 	TInt r=f.Temp(TheFs,_L(""),tempFileName,EFileRead);

   703 	test(r==KErrNone);

   704 	TParse p;

   705 	p.Set(tempFileName,NULL,NULL);

   706 	test(p.DrivePresent());

   707 	test(p.PathPresent());

   708 	test(p.NamePresent());

   709 	test(p.ExtPresent());

   710 	f.Close();

   711 

   712 	r=f.Replace(TheFs,_L("WELCOMETO"),EFileWrite);

   713 	test(r==KErrNone);

   714 	f.Close();

   715 	r=f.Replace(TheFs,_L("WELCOMETO.WRD"),EFileWrite);

   716 	test(r==KErrNone);

   717 	f.Close();

   718 	}

   719 

   720 // Nasty hack - mask attributes returned by RFile::Att() with this.

   721 // File server used to do this but that stopped the XIP attribute on the ROM file system

   722 // from being returned. It should really be up to the file system to return only

   723 // the attributes which it supports rather than having the file server unilaterally

   724 // mask off any attributes which don't exist on FAT.

   725 #define ATT_MASK 0x3f

   726 static void testFileAttributes()

   727 //

   728 // Test the archive attribute gets set

   729 //

   730 	{

   731 

   732 	test.Next(_L("Archive att is set after creation"));

   733 	RFile f;

   734 	TInt r=TheFs.Delete(_L("FILEATT.ARC"));

   735 	test(r==KErrNone || r==KErrNotFound);

   736 	r=f.Create(TheFs,_L("FILEATT.ARC"),EFileRead);

   737 	test(r==KErrNone);

   738 	TUint atts;

   739 	r=f.Att(atts);

   740 	test(r==KErrNone);

   741 	test((atts&ATT_MASK)==KEntryAttArchive);

   742 	TEntry fileAtt;

   743 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   744 	test(r==KErrNone);

   745 	test(fileAtt.iAtt==KEntryAttArchive);

   746 	f.Close();

   747 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   748 	test(r==KErrNone);

   749 	test(fileAtt.iAtt==KEntryAttArchive);

   750 

   751 	test.Next(_L("Archive att is set after a write"));

   752 	TheFs.SetAtt(_L("FILEATT.ARC"),0,KEntryAttArchive);

   753 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   754 	test(r==KErrNone);

   755 	test(fileAtt.iAtt==0);

   756 	r=f.Open(TheFs,_L("FILEATT.ARC"),EFileWrite);

   757 	test(r==KErrNone);

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

   759 	test(r==KErrNone);

   760 	r=f.Att(atts);

   761 	test(r==KErrNone);

   762 	test((atts&ATT_MASK)==KEntryAttArchive);

   763 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   764 	test(r==KErrNone);

   765 	test(fileAtt.iAtt==KEntryAttArchive);

   766 	f.Close();

   767 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   768 	test(r==KErrNone);

   769 	test(fileAtt.iAtt==KEntryAttArchive);

   770 

   771 	test.Next(_L("Archive att is set after setsize"));

   772 	TheFs.SetAtt(_L("FILEATT.ARC"),0,KEntryAttArchive);

   773 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   774 	test(r==KErrNone);

   775 	test(fileAtt.iAtt==0);

   776 	r=f.Open(TheFs,_L("FILEATT.ARC"),EFileWrite);

   777 	test(r==KErrNone);

   778 	r=f.SetSize(447);

   779 	test(r==KErrNone);

   780 	TInt size;

   781 	r=f.Size(size);

   782 	test(r==KErrNone);

   783 	test(size==447);

   784 	r=f.Att(atts);

   785 	test(r==KErrNone);

   786 	test((atts&ATT_MASK)==KEntryAttArchive);

   787 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   788 	test(r==KErrNone);

   789 	test(fileAtt.iAtt==KEntryAttArchive);

   790 	f.Close();

   791 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   792 	test(r==KErrNone);

   793 	test(fileAtt.iAtt==KEntryAttArchive);

   794 

   795 	test.Next(_L("Archive att is not set after open"));

   796 	r=TheFs.SetAtt(_L("FILEATT.ARC"),0,KEntryAttArchive);

   797 	test(r==KErrNone);

   798 	r=f.Open(TheFs,_L("FILEATT.ARC"),EFileWrite);

   799 	test(r==KErrNone);

   800 	r=f.Att(atts);

   801 	test(r==KErrNone);

   802 	test((atts&ATT_MASK)==0);

   803 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   804 	test(r==KErrNone);

   805 	test(fileAtt.iAtt==0);

   806 	f.Close();

   807 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   808 	test(r==KErrNone);

   809 	test(fileAtt.iAtt==0);

   810 

   811 	test.Next(_L("Archive att is not set after a read"));

   812 	TheFs.SetAtt(_L("FILEATT.ARC"),0,KEntryAttArchive);

   813 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   814 	test(r==KErrNone);

   815 	test(fileAtt.iAtt==0);

   816 	r=f.Open(TheFs,_L("FILEATT.ARC"),EFileWrite);

   817 	test(r==KErrNone);

   818 	TBuf8<16> readBuf;

   819 	r=f.Read(readBuf);

   820 	test(r==KErrNone);

   821 	r=f.Att(atts);

   822 	test(r==KErrNone);

   823 	test((atts&ATT_MASK)==0);

   824 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   825 	test(r==KErrNone);

   826 	test(fileAtt.iAtt==0);

   827 	f.Close();

   828 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   829 	test(r==KErrNone);

   830 	test(fileAtt.iAtt==0);

   831 

   832 	test.Next(_L("Archive att is set after replace"));

   833 	r=f.Replace(TheFs,_L("FILEATT.ARC"),EFileWrite);

   834 	test(r==KErrNone);

   835 	r=f.Att(atts);

   836 	test(r==KErrNone);

   837 	test((atts&ATT_MASK)==KEntryAttArchive);

   838 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   839 	test(r==KErrNone);

   840 	test(fileAtt.iAtt==KEntryAttArchive);

   841 	f.Close();

   842 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   843 	test(r==KErrNone);

   844 	test(fileAtt.iAtt==KEntryAttArchive);

   845 

   846 	test.Next(_L("Read only bit can be unset"));

   847 	r=TheFs.SetAtt(_L("FILEATT.ARC"),KEntryAttReadOnly|KEntryAttHidden,0);

   848 	test(r==KErrNone);

   849 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   850 	test(r==KErrNone);

   851 	test(fileAtt.iAtt==(KEntryAttReadOnly|KEntryAttHidden|KEntryAttArchive));

   852 

   853 	r=TheFs.SetAtt(_L("FILEATT.ARC"),0,KEntryAttHidden);

   854 	test(r==KErrNone);

   855 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   856 	test(r==KErrNone);

   857 	test(fileAtt.iAtt==(KEntryAttReadOnly|KEntryAttArchive));

   858 

   859 	r=TheFs.SetAtt(_L("FILEATT.ARC"),0,KEntryAttReadOnly);

   860 	test(r==KErrNone);

   861 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   862 	test(r==KErrNone);

   863 	test(fileAtt.iAtt==(KEntryAttArchive));

   864 

   865 	r=TheFs.SetAtt(_L("FILEATT.ARC"),KEntryAttReadOnly|KEntryAttHidden,0);

   866 	test(r==KErrNone);

   867 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   868 	test(r==KErrNone);

   869 	test(fileAtt.iAtt==(KEntryAttReadOnly|KEntryAttHidden|KEntryAttArchive));

   870 

   871 	r=TheFs.SetAtt(_L("FILEATT.ARC"),0,KEntryAttReadOnly);

   872 	test(r==KErrNone);

   873 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   874 	test(r==KErrNone);

   875 	test(fileAtt.iAtt==(KEntryAttHidden|KEntryAttArchive));

   876 

   877 	r=TheFs.SetAtt(_L("FILEATT.ARC"),0,KEntryAttHidden);

   878 	test(r==KErrNone);

   879 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   880 	test(r==KErrNone);

   881 	test(fileAtt.iAtt==(KEntryAttArchive));

   882 

   883 	TTime time(0);

   884 	r=TheFs.SetEntry(_L("FILEATT.ARC"),time,KEntryAttReadOnly|KEntryAttHidden,0);

   885 	test(r==KErrNone);

   886 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   887 	test(r==KErrNone);

   888 	test(fileAtt.iAtt==(KEntryAttReadOnly|KEntryAttHidden|KEntryAttArchive));

   889 

   890 	r=TheFs.SetEntry(_L("FILEATT.ARC"),time,0,KEntryAttHidden);

   891 	test(r==KErrNone);

   892 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   893 	test(r==KErrNone);

   894 	test(fileAtt.iAtt==(KEntryAttReadOnly|KEntryAttArchive));

   895 

   896 	r=TheFs.SetEntry(_L("FILEATT.ARC"),time,0,KEntryAttReadOnly);

   897 	test(r==KErrNone);

   898 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   899 	test(r==KErrNone);

   900 	test(fileAtt.iAtt==(KEntryAttArchive));

   901 

   902 	r=TheFs.SetEntry(_L("FILEATT.ARC"),time,KEntryAttReadOnly|KEntryAttHidden,0);

   903 	test(r==KErrNone);

   904 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   905 	test(r==KErrNone);

   906 	test(fileAtt.iAtt==(KEntryAttReadOnly|KEntryAttHidden|KEntryAttArchive));

   907 

   908 	r=TheFs.SetEntry(_L("FILEATT.ARC"),time,0,KEntryAttReadOnly);

   909 	test(r==KErrNone);

   910 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   911 	test(r==KErrNone);

   912 	test(fileAtt.iAtt==(KEntryAttHidden|KEntryAttArchive));

   913 

   914 	r=TheFs.SetEntry(_L("FILEATT.ARC"),time,0,KEntryAttHidden);

   915 	test(r==KErrNone);

   916 	r=TheFs.Entry(_L("FILEATT.ARC"),fileAtt);

   917 	test(r==KErrNone);

   918 	test(fileAtt.iAtt==(KEntryAttArchive));

   919 

   920 	test.Next(_L("Cashing the 'read-only' attribute"));

   921 	const TDesC& fname = _L("TEST.RO");

   922 

   923 	// Test RO attribute after creating a file

   924 	r=f.Create(TheFs,fname,EFileWrite);

   925 	test(r==KErrNone);

   926 	r=f.SetAtt(KEntryAttReadOnly,0);

   927 	test(r==KErrNone);

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

   929 	test(r==KErrNone);					// <-- here!

   930 	f.Close();

   931 

   932 	// Test we can't open for write or delete a RO file

   933 	r=f.Open(TheFs,fname,EFileWrite);

   934 	test(r==KErrAccessDenied);

   935 	r=TheFs.Delete(fname);

   936 	test(r==KErrAccessDenied);

   937 

   938 	// Tidy up and re-create test file

   939 	r=TheFs.SetAtt(fname,0,KEntryAttReadOnly);

   940 	test(r==KErrNone);

   941 	r=TheFs.Delete(fname);

   942 	test(r==KErrNone);

   943 	r=f.Create(TheFs,fname,EFileWrite);

   944 	test(r==KErrNone);

   945 	f.Close();

   946 

   947 	// Test RO attribute after opening a file

   948 	r=f.Open(TheFs,fname,EFileWrite);

   949 	test(r==KErrNone);

   950 	r=f.SetAtt(KEntryAttReadOnly,0);

   951 	test(r==KErrNone);

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

   953 	test(r==KErrNone);

   954 	f.Close();

   955 

   956 	// Tidy up

   957 	r=TheFs.SetAtt(fname,0,KEntryAttReadOnly);

   958 	test(r==KErrNone);

   959 	r=TheFs.Delete(fname);

   960 	test(r==KErrNone);

   961 	}

   962 

   963 static void testShortNameAccessorFunctions()

   964 //

   965 // Test RFs::GetShortName(...)

   966 //

   967 	{

   968 	test.Next(_L("Test short name accessor functions"));

   969 

   970     if(!gShortFileNamesSupported)

   971         {

   972         test.Printf(_L("Short Names are not supported!. Skipping..."));

   973         return;

   974         }

   975 

   976 

   977 	TBuf<64> sessionPath;

   978 	TInt r=TheFs.SessionPath(sessionPath);

   979 	test(r==KErrNone);

   980 	RFile f;

   981 	r=TheFs.MkDirAll(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\RANDOM.ENDBIT"));

   982 	test(r==KErrNone || r==KErrAlreadyExists);

   983 	r=f.Replace(TheFs,_L("LONGFILENAME.LONGEXT"),EFileWrite);

   984 	test(r==KErrNone);

   985 	f.Close();

   986 	r=f.Replace(TheFs,_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\LONGFILENAME.LONGEXT"),EFileWrite);

   987 	test(r==KErrNone);

   988 	f.Close();

   989 	r=f.Replace(TheFs,_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\BAD CHAR"),EFileWrite);

   990 	test(r==KErrNone);

   991 	f.Close();

   992 	r=f.Replace(TheFs,_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\GoodCHAR.TXT"),EFileWrite);

   993 	test(r==KErrNone);

   994 	f.Close();

   995 	TBuf<12> shortName1;

   996 	TBuf<12> shortName2;

   997 	TBuf<12> shortName3;

   998 	TBuf<12> shortName4;

   999 	TBuf<12> shortName5;

  1000 	r=TheFs.GetShortName(_L("LONGFILENAME.LONGEXT"),shortName1);

  1001 	test(r==KErrNone);

  1002 	r=TheFs.GetShortName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\LONGFILENAME.LONGEXT"),shortName2);

  1003 	test(r==KErrNone);

  1004 	r=TheFs.GetShortName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\BAD CHAR"),shortName3);

  1005 	test(r==KErrNone);

  1006 	r=TheFs.GetShortName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\GOODCHAR.TXT"),shortName4);

  1007 	test(r==KErrNone);

  1008 	r=TheFs.GetShortName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY"),shortName5);

  1009 	test(r==KErrNone);

  1010 

  1011 	if(Is_Win32(TheFs, gDriveNum))

  1012 		{

  1013 		test(shortName1==_L("LONGFI~1.LON"));

  1014 		test(shortName2==_L("LONGFI~1.LON"));

  1015 		test(shortName3==_L("BADCHA~1"));

  1016 		test(shortName4.FindF(_L("GOODCHAR.TXT"))>=0);

  1017 		test(shortName5==_L("MIDDLE~1"));

  1018 		}

  1019 	else if(!IsTestingLFFS())

  1020 		{

  1021 		// LFFS short names not the same as VFAT ones

  1022 		test(shortName1==_L("LONGFI~1.LON"));

  1023 		test(shortName2==_L("LONGFI~1.LON"));

  1024 		test(shortName3==_L("BAD_CHAR"));

  1025 		test(shortName4.FindF(_L("GOODCHAR.TXT"))>=0);

  1026 		test(shortName5==_L("MIDDLE~1"));

  1027 		}

  1028 

  1029 	TFileName longName1;

  1030 	TFileName longName2;

  1031 	TFileName longName3;

  1032 	TFileName longName4;

  1033 	TFileName longName5;

  1034 

  1035 	if (Is_Win32(TheFs, gDriveNum))

  1036 		{

  1037 		r=TheFs.GetLongName(_L("LONGFI~1.LON"),longName1);

  1038 		test(r==KErrNone);

  1039 		r=TheFs.GetLongName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\LONGFI~1.LON"),longName2);

  1040 		test(r==KErrNone);

  1041 		r=TheFs.GetLongName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\BADCHA~1"),longName3);

  1042 		test(r==KErrNone);

  1043 		r=TheFs.GetLongName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\GOODCHAR.TXT"),longName4);

  1044 		test(r==KErrNone);

  1045 		r=TheFs.GetLongName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE~1"),longName5);

  1046 		test(r==KErrNone);

  1047 		}

  1048 	else if (!IsTestingLFFS())

  1049 		{

  1050 		r=TheFs.GetLongName(_L("LONGFI~1.LON"),longName1);

  1051 		test(r==KErrNone);

  1052 		r=TheFs.GetLongName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\LONGFI~1.LON"),longName2);

  1053 		test(r==KErrNone);

  1054 		r=TheFs.GetLongName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\BAD_CHAR"),longName3);

  1055 		test(r==KErrNone);

  1056 		r=TheFs.GetLongName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\GOODCHAR.TXT"),longName4);

  1057 		test(r==KErrNone);

  1058 		r=TheFs.GetLongName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE~1"),longName5);

  1059 		test(r==KErrNone);

  1060 		}

  1061     else

  1062     	{

  1063 		// LFFS longname tests

  1064         r=TheFs.GetLongName(shortName1,longName1);

  1065         test(r==KErrNone);

  1066         r=TheFs.SetSessionPath(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-DIRECTORY\\LASTDIR\\"));

  1067         test(r==KErrNone);

  1068         r=TheFs.GetLongName(shortName2,longName2);

  1069         test(r==KErrNone);

  1070         r=TheFs.GetLongName(shortName3,longName3);

  1071         test(r==KErrNone);

  1072         r=TheFs.GetLongName(shortName4,longName4);

  1073         test(r==KErrNone);

  1074         r=TheFs.SetSessionPath(_L("\\F32-TST\\TFILE\\TOPLEVEL\\"));

  1075         test(r==KErrNone);

  1076         r=TheFs.GetLongName(shortName5,longName5);

  1077         test(r==KErrNone);

  1078         r=TheFs.SetSessionPath(sessionPath);

  1079         test(r==KErrNone);

  1080     	}

  1081 

  1082 	test(longName1==_L("LONGFILENAME.LONGEXT"));

  1083 	test(longName2==_L("LONGFILENAME.LONGEXT"));

  1084 	test(longName3==_L("BAD CHAR"));

  1085 	test(longName4.FindF(_L("GOODCHAR.TXT"))>=0);

  1086 	test(longName5==_L("MIDDLE-DIRECTORY"));

  1087 

  1088 	r=TheFs.GetShortName(_L("XXX.YYY"),shortName1);

  1089 	test(r==KErrNotFound);

  1090 	r=TheFs.GetShortName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-YROTCERID\\LASTDIR\\BAD-CHAR"),shortName1);

  1091 	test(r==KErrPathNotFound);

  1092 	r=TheFs.GetLongName(_L("XXX.YYY"),longName1);

  1093 	test(r==KErrNotFound);

  1094 	r=TheFs.GetLongName(_L("\\F32-TST\\TFILE\\TOPLEVEL\\MIDDLE-YROTCERID\\LASTDIR\\BAD-CHAR"),longName1);

  1095 	test(r==KErrPathNotFound);

  1096 

  1097 	r=TheFs.Delete(_L("LONGFILENAME.LONGEXT"));

  1098 	test(r==KErrNone);

  1099 

  1100 	TEntry romEntry;

  1101 	r=TheFs.Entry(_L("Z:\\System"),romEntry);

  1102 	if (r==KErrNotReady)

  1103 		{

  1104 		test.Printf(_L("ERROR: No rom filesystem present"));

  1105 		//test.Getch();

  1106 		//return;

  1107 		}

  1108 	test(r==KErrNone);

  1109 	TBuf<64> romFileName=_L("Z:\\");

  1110 	romFileName.Append(romEntry.iName);

  1111 	r=TheFs.GetShortName(romFileName,shortName1);

  1112 	test(r==KErrNotSupported);

  1113 	r=TheFs.GetLongName(_L("Z:\\system"),longName1);

  1114 	test(r==KErrNotSupported);

  1115 	}

  1116 

  1117 static void RmDir(const TDesC& aDirName)

  1118 //

  1119 // Remove a directory

  1120 //

  1121 	{

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

  1123 	test(fMan!=NULL);

  1124 	TInt r=TheFs.SessionPath(gSessionPath);

  1125 	test(r==KErrNone);

  1126 	r=TheFs.CheckDisk(gSessionPath);

  1127 	if (r!=KErrNone && r!=KErrNotSupported)

  1128 		ReportCheckDiskFailure(r);

  1129 

  1130 	TFileName removeDirName = gSessionPath;

  1131 	removeDirName.Append(aDirName);

  1132 

  1133 	fMan->Attribs(removeDirName, 0, KEntryAttReadOnly, 0, CFileMan::ERecurse);

  1134 	r=fMan->RmDir(removeDirName);