Mercurial Mercurial > oss > FCL > sf > os > kernelhwsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
kerneltest/f32test/server/b_gen.cpp
branchRCL_3
changeset 257 3e88ff8f41d5
parent 256 c1f20ce4abcf
equal deleted inserted replaced
256:c1f20ce4abcf 257:3e88ff8f41d5 
    11 // Contributors:
 
    11 // Contributors:
 
    12 //
 
    12 //
 
    13 // Description:
 
    13 // Description:
 
    14 //
 
    14 //
 
    15 
    15 
    16 #define __E32TEST_EXTENSION__
 
       
    17 #include <f32file.h>
 
    16 #include <f32file.h>
 
    18 #include <e32test.h>
 
    17 #include <e32test.h>
 
    19 #include <e32math.h>
 
    18 #include <e32math.h>
 
    20 #include <e32hal.h>
 
    19 #include <e32hal.h>
 
    21 #include "t_server.h"
 
    20 #include "t_server.h"
 
    31 // Modified from BB's epoc test code
 
    30 // Modified from BB's epoc test code
 
    32 
    31 
    33 #define MINIMUM_DATE (315532800L)
 
    32 #define MINIMUM_DATE (315532800L)
 
    34 #define DateTests   10
 
    33 #define DateTests   10
 
    35 
    34 
       
    35 // GLREF_D P_DEVICE p_file;
 
       
    36 // GLREF_D P_DEVICE p_wind,p_screen,p_cons;
 
    36 
    37 
    37 TBuf<0x100> gNameBuf;
 
    38 TBuf<0x100> gNameBuf;
 
    38 TBuf<0x100> gNameOut;
 
    39 TBuf<0x100> gNameOut;
 
    39 RFile gFile;
 
    40 RFile gFile;
 
    40 RFile gFileErr;
 
    41 RFile gFileErr;
 
    49 static TEntry gFileEntry;
 
    50 static TEntry gFileEntry;
 
    50 static TVolumeInfo volInfo;
 
    51 static TVolumeInfo volInfo;
 
    51 static TFileName pathBuf;
 
    52 static TFileName pathBuf;
 
    52 
    53 
    53 
    54 
    54 
    55 const TInt NameErr=KErrBadName;
 
       
    56 const TInt DirErr=KErrPathNotFound;
 
       
    57 const TInt AccessErr=KErrAccessDenied;
 
       
    58 const TInt LockedErr=KErrInUse;
 
       
    59 const TInt ExistsErr=KErrAlreadyExists;
 
       
    60 const TInt NotExistsErr=KErrNotFound;
 
       
    61 const TInt EofErr=KErrEof;
 
       
    62 const TInt DeviceErr=KErrNotReady;
 
       
    63 //LOCAL_D TInt NoFileSystemErr=KErrNotReady;
 
       
    64 //LOCAL_D TInt NotSupportedErr=KErrNotSupported;
 
       
    65 const TInt ReadOnlyErr=KErrAccessDenied;
 
       
    66 
       
    67 const TInt P_FASTREAM=EFileStream;
 
       
    68 const TInt P_FAEXEC=0;
 
       
    69 const TInt P_FAMOD=KEntryAttArchive;
 
       
    70 const TInt P_FAREAD=KEntryAttReadOnly;
 
       
    71 //LOCAL_D TInt P_FAHIDDEN=KEntryAttHidden;
 
       
    72 //LOCAL_D TInt P_FASYSTEM=KEntryAttSystem;
 
       
    73 //static TInt P_FAVOLUME=KEntryAttVolume;
 
       
    74 const TInt P_FADIR=KEntryAttDir;
 
       
    75 const TInt P_FRANDOM=0;
 
       
    76 const TInt P_FABS=ESeekStart;
 
       
    77 
       
    78 const TInt P_FUPDATE=EFileWrite;
 
    55 
    79 
    56 
    80 
    57 static void doError(const TDesC &aMess, TInt anErr, TInt line)
 
    81 static void doError(const TDesC &aMess, TInt anErr, TInt line)
 
    58 	{ 
    82 	{ 
    59     test.Printf(_L("%S failed at line %d. Error %d\n"),&aMess, line, anErr);
 
    83     test.Printf(_L("%S failed at line %d. Error %d\n"),&aMess, line, anErr);
 
   135 	gDir.Close();
 
   159 	gDir.Close();
 
   136 	
   160 	
   137 	TChar drive(aDirName[0]);
 
   161 	TChar drive(aDirName[0]);
 
   138 	TInt driveNo;
 
   162 	TInt driveNo;
 
   139 	c=RFs::CharToDrive(drive,driveNo);
 
   163 	c=RFs::CharToDrive(drive,driveNo);
 
   140 	test_KErrNone(c);
 
   164 	test(c==KErrNone);
 
   141 	if ((c=TheFs.Volume(volInfo,driveNo))!=KErrNone)
 
   165 	if ((c=TheFs.Volume(volInfo,driveNo))!=KErrNone)
 
   142 		Error(_L("Device info 1000"),c);
 
   166 		Error(_L("Device info 1000"),c);
 
   143     }
 
   167     }
 
   144 
   168 
   145 
   169 
   174 	test.Printf(_L("Device info: %S\n"),&aDeviceName);
 
   198 	test.Printf(_L("Device info: %S\n"),&aDeviceName);
 
   175 	TInt drive=KDefaultDrive;
 
   199 	TInt drive=KDefaultDrive;
 
   176 	if (aDeviceName.Length())
 
   200 	if (aDeviceName.Length())
 
   177 		{
 
   201 		{
 
   178 		c=RFs::CharToDrive(aDeviceName[0],drive);
 
   202 		c=RFs::CharToDrive(aDeviceName[0],drive);
 
   179 		test_KErrNone(c);
 
   203 		test(c==KErrNone);
 
   180 		}		
   204 		}		
   181 	if ((c=TheFs.Volume(volInfo,drive))!=anErr)
 
   205 	if ((c=TheFs.Volume(volInfo,drive))!=anErr)
 
   182 		Error(_L("Device info"),c);
 
   206 		Error(_L("Device info"),c);
 
   183 	if (anErr==0)
 
   207 	if (anErr==0)
 
   184 		{
 
   208 		{
 
   201 		Error(_L("Get info 100"),c);
 
   225 		Error(_L("Get info 100"),c);
 
   202 	if (anErr==0)
 
   226 	if (anErr==0)
 
   203 		{
 
   227 		{
 
   204 		if (aFileName.Length()>=2 && aFileName[0]=='Z' && aFileName[1]==':')
 
   228 		if (aFileName.Length()>=2 && aFileName[0]=='Z' && aFileName[1]==':')
 
   205 			{
 
   229 			{
 
   206 			if ((gFileEntry.iAtt&(KEntryAttReadOnly|EFileStream)) != (TUint32)(KEntryAttReadOnly|EFileStream) && gFileEntry.iAtt!=KEntryAttDir)
 
   230 			if ((gFileEntry.iAtt&(P_FAREAD|P_FAEXEC|P_FASTREAM)) != (TUint32)(P_FAREAD|P_FAEXEC|P_FASTREAM) && gFileEntry.iAtt!=KEntryAttDir)
 
   207 				Error(_L("Info status check Z:\\"),0);
 
   231 				Error(_L("Info status check Z:\\"),0);
 
   208 			}
 
   232 			}
 
   209 		else
 
   233 		else
 
   210 			{
 
   234 			{
 
   211 			if (gFileEntry.iAtt&KEntryAttDir)
 
   235 			if (gFileEntry.iAtt&KEntryAttDir)
 
   212 				return; // Found directory entry
 
   236 				return; // Found directory entry
 
   213 			if (gFileEntry.iAtt!=(TUint32)(EFileStream|KEntryAttArchive))
 
   237 			if (gFileEntry.iAtt!=(TUint32)(P_FASTREAM|P_FAMOD))
 
   214 				Error(_L("Info status check"),0);
 
   238 				Error(_L("Info status check"),0);
 
   215 			if (gFileEntry.iSize!=0L)
 
   239 			if (gFileEntry.iSize!=0L)
 
   216 				Error(_L("Info size check"),0);
 
   240 				Error(_L("Info size check"),0);
 
   217 			}
 
   241 			}
 
   218 		}
 
   242 		}
 
   228 	if ((c=TheFs.Rename(aRName,aDName))!=KErrNone)
 
   252 	if ((c=TheFs.Rename(aRName,aDName))!=KErrNone)
 
   229 		Error(_L("Rename 92"),c);
 
   253 		Error(_L("Rename 92"),c);
 
   230 	if ((c=gFile.Open(TheFs,aDName,EFileStream))!=KErrNone)
 
   254 	if ((c=gFile.Open(TheFs,aDName,EFileStream))!=KErrNone)
 
   231 		Error(_L("Open 92"),c);
 
   255 		Error(_L("Open 92"),c);
 
   232 	gFile.Close();
 
   256 	gFile.Close();
 
   233 	if ((c=TheFs.Delete(aRName))!=KErrNotFound)
 
   257 	if ((c=TheFs.Delete(aRName))!=NotExistsErr)
 
   234 		Error(_L("Delete 92"),c);
 
   258 		Error(_L("Delete 92"),c);
 
   235 	}
 
   259 	}
 
   236 
   260 
   237 static void testRenameToRoot(const TDesC& pName,const TDesC& rName)
 
   261 static void testRenameToRoot(const TDesC& pName,const TDesC& rName)
 
   238 //
 
   262 //
 
   247 	if ((c=TheFs.Rename(pName,rName))!=KErrNone)
 
   271 	if ((c=TheFs.Rename(pName,rName))!=KErrNone)
 
   248 		Error(_L("Rename 91"),c);
 
   272 		Error(_L("Rename 91"),c);
 
   249 	if ((c=gFile.Open(TheFs,rName,EFileStream))!=KErrNone)
 
   273 	if ((c=gFile.Open(TheFs,rName,EFileStream))!=KErrNone)
 
   250 		Error(_L("Open 91"),c);
 
   274 		Error(_L("Open 91"),c);
 
   251 	gFile.Close();
 
   275 	gFile.Close();
 
   252 	if ((c=TheFs.Delete(pName))!=KErrNotFound)
 
   276 	if ((c=TheFs.Delete(pName))!=NotExistsErr)
 
   253 		Error(_L("Delete 91"),c);
 
   277 		Error(_L("Delete 91"),c);
 
   254 	}
 
   278 	}
 
   255 
   279 
   256 static void verifyTestPat1()
 
   280 static void verifyTestPat1()
 
   257 //
 
   281 //
 
   282 	TBuf<32> dirname;
 
   306 	TBuf<32> dirname;
 
   283 	dirname.Copy(KDir1);
 
   307 	dirname.Copy(KDir1);
 
   284 	dirname.Append(KPathDelimiter);
 
   308 	dirname.Append(KPathDelimiter);
 
   285 	MakeDir(dirname);
 
   309 	MakeDir(dirname);
 
   286 	TInt err = TheFs.Rename(KDir1, KDir2);
 
   310 	TInt err = TheFs.Rename(KDir1, KDir2);
 
   287 	test_KErrNone(err);
 
   311 	test(err == KErrNone);
 
   288 	err = TheFs.RmDir(dirname);
 
   312 	err = TheFs.RmDir(dirname);
 
   289 	test_KErrNone(err);
 
   313 	test(err == KErrNone);
 
   290 	err = TheFs.RmDir(KDir1);
 
   314 	err = TheFs.RmDir(KDir1);
 
   291 	test_KErrNone(err);
 
   315 	test(err == KErrNone);
 
   292 	}
 
   316 	}
 
   293 	
   317 	
   294 static void testRename()
 
   318 static void testRename()
 
   295 //
 
   319 //
 
   296 // Test TheFs.Rename function.
 
   320 // Test TheFs.Rename function.
 
   301 	TInt i;
 
   325 	TInt i;
 
   302 	TInt c;
 
   326 	TInt c;
 
   303 	test.Printf(_L("Test TheFs.Rename\n"));
 
   327 	test.Printf(_L("Test TheFs.Rename\n"));
 
   304 
   328 
   305 	test.Printf(_L("Test rename into root\n"));
 
   329 	test.Printf(_L("Test rename into root\n"));
 
   306 	if ((c=gFile.Replace(TheFs,_L("\\TESTPAT1.DAT"),EFileStream|EFileWrite))!=KErrNone)
 
   330 	if ((c=gFile.Replace(TheFs,_L("\\TESTPAT1.DAT"),EFileStream|P_FUPDATE))!=KErrNone)
 
   307 		Error(_L("Create testpat1"),c);
 
   331 		Error(_L("Create testpat1"),c);
 
   308 	gDataBuf.Fill('X',512);
 
   332 	gDataBuf.Fill('X',512);
 
   309 	if ((c=gFile.Write(gDataBuf,512))!=KErrNone)
 
   333 	if ((c=gFile.Write(gDataBuf,512))!=KErrNone)
 
   310 		Error(_L("Write 90"),c);
 
   334 		Error(_L("Write 90"),c);
 
   311 	gFile.Close();
 
   335 	gFile.Close();
 
   338 	verifyTestPat1();
 
   362 	verifyTestPat1();
 
   339 	if ((c=TheFs.Delete(_L("\\TESTPAT1.DAT")))!=KErrNone)
 
   363 	if ((c=TheFs.Delete(_L("\\TESTPAT1.DAT")))!=KErrNone)
 
   340 		Error(_L("Delete 80"),c);
 
   364 		Error(_L("Delete 80"),c);
 
   341 
   365 
   342 	test.Printf(_L("Test rename with wild cards\n"));
 
   366 	test.Printf(_L("Test rename with wild cards\n"));
 
   343 	if ((c=TheFs.Rename(_L("*.*"),_L("FRED")))!=KErrBadName)
 
   367 	if ((c=TheFs.Rename(_L("*.*"),_L("FRED")))!=NameErr)
 
   344 		Error(_L("Rename 100"),c);
 
   368 		Error(_L("Rename 100"),c);
 
   345 	if ((c=TheFs.Rename(_L("?"),_L("FRED")))!=KErrBadName)
 
   369 	if ((c=TheFs.Rename(_L("?"),_L("FRED")))!=NameErr)
 
   346 		Error(_L("Rename 101"),c);
 
   370 		Error(_L("Rename 101"),c);
 
   347 	if ((c=TheFs.Rename(_L(""),_L("FRED")))!=KErrBadName) // KErrBadName)
 
   371 	if ((c=TheFs.Rename(_L(""),_L("FRED")))!=KErrBadName) // NameErr)
 
   348 		Error(_L("Rename 101.11"),c);
 
   372 		Error(_L("Rename 101.11"),c);
 
   349 	if ((c=TheFs.Rename(_L("."),_L("FRED")))!=KErrBadName)
 
   373 	if ((c=TheFs.Rename(_L("."),_L("FRED")))!=NameErr)
 
   350 		Error(_L("Rename 101.12"),c);
 
   374 		Error(_L("Rename 101.12"),c);
 
   351 	if ((c=TheFs.Rename(_L("NOEXIST"),_L("*")))!=KErrBadName)
 
   375 	if ((c=TheFs.Rename(_L("NOEXIST"),_L("*")))!=NameErr)
 
   352 		Error(_L("Rename 101.1"),c);
 
   376 		Error(_L("Rename 101.1"),c);
 
   353 	if ((c=gFile.Create(TheFs,_L("FILE1"),EFileStream))!=KErrNone)
 
   377 	if ((c=gFile.Create(TheFs,_L("FILE1"),EFileStream))!=KErrNone)
 
   354 		Error(_L("Create 101.2"),c);
 
   378 		Error(_L("Create 101.2"),c);
 
   355 	gFile.Close();
 
   379 	gFile.Close();
 
   356 	if ((c=TheFs.Rename(_L("FILE1"),_L("AAA?")))!=KErrBadName)
 
   380 	if ((c=TheFs.Rename(_L("FILE1"),_L("AAA?")))!=NameErr)
 
   357 		Error(_L("Rename 101.3"),c);
 
   381 		Error(_L("Rename 101.3"),c);
 
   358 	if ((c=TheFs.Rename(_L("FILE1"),_L("")))!=KErrBadName) // KErrBadName)
 
   382 	if ((c=TheFs.Rename(_L("FILE1"),_L("")))!=KErrBadName) // NameErr)
 
   359 		Error(_L("Rename 101.41"),c);
 
   383 		Error(_L("Rename 101.41"),c);
 
   360 	if ((c=TheFs.Rename(_L(""),_L("")))!=KErrBadName) // KErrBadName)
 
   384 	if ((c=TheFs.Rename(_L(""),_L("")))!=KErrBadName) // NameErr)
 
   361 		Error(_L("Rename 101.42"),c);
 
   385 		Error(_L("Rename 101.42"),c);
 
   362 	if ((c=TheFs.Delete(_L("FILE1")))!=KErrNone)
 
   386 	if ((c=TheFs.Delete(_L("FILE1")))!=KErrNone)
 
   363 		Error(_L("Delete 101.5"),c);
 
   387 		Error(_L("Delete 101.5"),c);
 
   364 	if ((c=TheFs.Rename(_L("\\"),_L("FRED")))!=KErrBadName)
 
   388 	if ((c=TheFs.Rename(_L("\\"),_L("FRED")))!=NameErr)
 
   365 		Error(_L("Rename 101.6"),c);
 
   389 		Error(_L("Rename 101.6"),c);
 
   366 
   390 
   367 	test.Printf(_L("Test rename of directories\n"));
 
   391 	test.Printf(_L("Test rename of directories\n"));
 
   368 	if ((c=TheFs.MkDir(_L("\\DIR1\\")))!=KErrNone)
 
   392 	if ((c=TheFs.MkDir(_L("\\DIR1\\")))!=KErrNone)
 
   369 		Error(_L("Make dir 102"),c);
 
   393 		Error(_L("Make dir 102"),c);
 
   370 	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\A2345678.123")))!=KErrNone)
 
   394 	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\A2345678.123")))!=KErrNone)
 
   371 		Error(_L("Rename 103.1"),c);
 
   395 		Error(_L("Rename 103.1"),c);
 
   372 	if ((c=TheFs.Rename(_L("\\A2345678.123"),_L("\\DIR2")))!=KErrNone)
 
   396 	if ((c=TheFs.Rename(_L("\\A2345678.123"),_L("\\DIR2")))!=KErrNone)
 
   373 		Error(_L("Rename 103.2"),c);
 
   397 		Error(_L("Rename 103.2"),c);
 
   374 	if ((c=TheFs.Rename(_L("\\DIR2"),_L("\\A234567.1234")))!=KErrNone) // ****** KErrBadName) Long filenames are supported
 
   398 	if ((c=TheFs.Rename(_L("\\DIR2"),_L("\\A234567.1234")))!=KErrNone) // ****** NameErr) Long filenames are supported
 
   375 		Error(_L("Rename 103.3"),c);
 
   399 		Error(_L("Rename 103.3"),c);
 
   376 	if ((c=TheFs.Rename(_L("\\A234567.1234"),_L("\\DIR2")))!=KErrNone)
 
   400 	if ((c=TheFs.Rename(_L("\\A234567.1234"),_L("\\DIR2")))!=KErrNone)
 
   377 		Error(_L("Rename 103.3"),c);
 
   401 		Error(_L("Rename 103.3"),c);
 
   378 	if ((c=TheFs.MkDir(_L("\\DIR1\\")))!=KErrNone)
 
   402 	if ((c=TheFs.MkDir(_L("\\DIR1\\")))!=KErrNone)
 
   379 		Error(_L("Make dir 104"),c);
 
   403 		Error(_L("Make dir 104"),c);
 
   380 
   404 
   381 	test.Printf(_L("Test rename of open files\n"));
 
   405 	test.Printf(_L("Test rename of open files\n"));
 
   382 	if ((c=gFile.Create(TheFs,_L("\\DIR1\\FILE1"),EFileStreamText))!=KErrNone)
 
   406 	if ((c=gFile.Create(TheFs,_L("\\DIR1\\FILE1"),EFileStreamText))!=KErrNone)
 
   383 		Error(_L("Create 105"),c);
 
   407 		Error(_L("Create 105"),c);
 
   384 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE1")))!=KErrInUse)
 
   408 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE1")))!=LockedErr)
 
   385 		Error(_L("Rename 106"),c);
 
   409 		Error(_L("Rename 106"),c);
 
   386 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR2\\FILE1")))!=KErrInUse)
 
   410 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR2\\FILE1")))!=LockedErr)
 
   387 		Error(_L("Rename 106.1"),c);
 
   411 		Error(_L("Rename 106.1"),c);
 
   388 	if ((c=gFile2.Open(TheFs,_L("\\DIR2\\FILE1"),EFileStream))!=KErrNotFound)
 
   412 	if ((c=gFile2.Open(TheFs,_L("\\DIR2\\FILE1"),EFileStream))!=NotExistsErr)
 
   389 		Error(_L("Create 105"),c);
 
   413 		Error(_L("Create 105"),c);
 
   390 	gFile.Close();
 
   414 	gFile.Close();
 
   391 
   415 
   392 	test.Printf(_L("Test rename to same name\n"));
 
   416 	test.Printf(_L("Test rename to same name\n"));
 
   393 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE1")))!=KErrNone) // !=KErrAlreadyExists)
 
   417 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE1")))!=KErrNone) // !=ExistsErr)
 
   394 		Error(_L("Rename 105.1"),c);
 
   418 		Error(_L("Rename 105.1"),c);
 
   395 	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\DIR1")))!=KErrNone) // !=KErrAlreadyExists)
 
   419 	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\DIR1")))!=KErrNone) // !=ExistsErr)
 
   396 		Error(_L("Rename 105.2"),c);
 
   420 		Error(_L("Rename 105.2"),c);
 
   397 
   421 
   398 	test.Printf(_L("Test rename of read-only files\n"));     // IS ALLOWED //
 
   422 	test.Printf(_L("Test rename of read-only files\n"));     // IS ALLOWED //
 
   399 	if ((c=TheFs.SetAtt(_L("\\DIR1\\FILE1"),KEntryAttReadOnly,0))!=KErrNone)
 
   423 	if ((c=TheFs.SetAtt(_L("\\DIR1\\FILE1"),KEntryAttReadOnly,0))!=KErrNone)
 
   400 		Error(_L("Att 106"),c);
 
   424 		Error(_L("Att 106"),c);
 
   401 	if ((c=TheFs.Entry(_L("\\DIR1\\FILE1"),gFileEntry))!=KErrNone)
 
   425 	if ((c=TheFs.Entry(_L("\\DIR1\\FILE1"),gFileEntry))!=KErrNone)
 
   402 		Error(_L("File info 106.1"),c);
 
   426 		Error(_L("File info 106.1"),c);
 
   403 	test.Printf(_L("STATUS=%04x\n"),gFileEntry.iAtt);
 
   427 	test.Printf(_L("STATUS=%04x\n"),gFileEntry.iAtt);
 
   404 	if (gFileEntry.iAtt!=(TUint32)(KEntryAttReadOnly|EFileStream|KEntryAttArchive))
 
   428 	if (gFileEntry.iAtt!=(TUint32)(P_FAREAD|P_FASTREAM|P_FAMOD))
 
   405 		Error(_L("Status check 106.2"),0);
 
   429 		Error(_L("Status check 106.2"),0);
 
   406 	if ((c=TheFs.Entry(_L("\\DIR1"),gFileEntry))!=KErrNone)
 
   430 	if ((c=TheFs.Entry(_L("\\DIR1"),gFileEntry))!=KErrNone)
 
   407 		Error(_L("File info 106.3"),c);
 
   431 		Error(_L("File info 106.3"),c);
 
   408 	test.Printf(_L("STATUS=%04x\n"),gFileEntry.iAtt);
 
   432 	test.Printf(_L("STATUS=%04x\n"),gFileEntry.iAtt);
 
   409 	if (gFileEntry.iAtt!=(TUint32)(EFileStream|KEntryAttDir))
 
   433 	if (gFileEntry.iAtt!=(TUint32)(P_FASTREAM|P_FADIR))
 
   410 		Error(_L("Status check 106.4"),0);
 
   434 		Error(_L("Status check 106.4"),0);
 
   411 
   435 
   412 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE1")))!=KErrNone) // !=KErrAlreadyExists)
 
   436 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE1")))!=KErrNone) // !=ExistsErr)
 
   413 		Error(_L("Rename 107"),c);
 
   437 		Error(_L("Rename 107"),c);
 
   414 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE2")))!=KErrNone)
 
   438 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE1"),_L("\\DIR1\\FILE2")))!=KErrNone)
 
   415 		Error(_L("Rename 108"),c);
 
   439 		Error(_L("Rename 108"),c);
 
   416 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE2"),_L("\\DIR2\\FILE2")))!=KErrNone)
 
   440 	if ((c=TheFs.Rename(_L("\\DIR1\\FILE2"),_L("\\DIR2\\FILE2")))!=KErrNone)
 
   417 		Error(_L("Rename 109"),c);
 
   441 		Error(_L("Rename 109"),c);
 
   429 	if ((c=gFile.Open(TheFs,_L("\\DIR2\\FILE1"),EFileStream))!=KErrNone)
 
   453 	if ((c=gFile.Open(TheFs,_L("\\DIR2\\FILE1"),EFileStream))!=KErrNone)
 
   430 		Error(_L("Exist 113"),c);
 
   454 		Error(_L("Exist 113"),c);
 
   431 	gFile.Close();
 
   455 	gFile.Close();
 
   432 
   456 
   433 	test.Printf(_L("Test rename of directories across directories\n"));
 
   457 	test.Printf(_L("Test rename of directories across directories\n"));
 
   434 	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\DIR2\\DIR1")))!=KErrNone) // ******** KErrAccessDenied)
 
   458 	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\DIR2\\DIR1")))!=KErrNone) // ******** AccessErr)
 
   435 		Error(_L("Rename 114"),c);
 
   459 		Error(_L("Rename 114"),c);
 
   436 	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\")))!=KErrBadName)
 
   460 	if ((c=TheFs.Rename(_L("\\DIR1"),_L("\\")))!=NameErr)
 
   437 		Error(_L("Rename 114.1"),c);
 
   461 		Error(_L("Rename 114.1"),c);
 
   438 
   462 
   439 	if ((c=TheFs.Delete(_L("\\DIR2\\FILE1")))!=KErrNone)
 
   463 	if ((c=TheFs.Delete(_L("\\DIR2\\FILE1")))!=KErrNone)
 
   440 		Error(_L("Delete 115"),c);
 
   464 		Error(_L("Delete 115"),c);
 
   441 	if ((c=TheFs.RmDir(_L("\\DIR2\\DIR1\\")))!=KErrNone)
 
   465 	if ((c=TheFs.RmDir(_L("\\DIR2\\DIR1\\")))!=KErrNone)
 
   457 	test.Printf(_L("Test delete non-empty directories\n"));
 
   481 	test.Printf(_L("Test delete non-empty directories\n"));
 
   458 	if ((c=TheFs.MkDir(_L("\\TESTDIR\\")))!=KErrNone)
 
   482 	if ((c=TheFs.MkDir(_L("\\TESTDIR\\")))!=KErrNone)
 
   459 		Error(_L("Make dir 500"),c);
 
   483 		Error(_L("Make dir 500"),c);
 
   460 	if ((c=gFile.Create(TheFs,_L("\\TESTDIR\\NAME.EXT"),EFileStream))!=KErrNone)
 
   484 	if ((c=gFile.Create(TheFs,_L("\\TESTDIR\\NAME.EXT"),EFileStream))!=KErrNone)
 
   461 		Error(_L("Create"),c);
 
   485 		Error(_L("Create"),c);
 
   462 	if ((c=TheFs.Delete(_L("\\TESTDIR\\")))!=KErrBadName) // ******* KErrAccessDenied)
 
   486 	if ((c=TheFs.Delete(_L("\\TESTDIR\\")))!=KErrBadName) // ******* AccessErr)
 
   463 		Error(_L("Delete 501"),c);
 
   487 		Error(_L("Delete 501"),c);
 
   464 
   488 
   465 	test.Printf(_L("Test delete open file\n"));
 
   489 	test.Printf(_L("Test delete open file\n"));
 
   466 	if ((c=TheFs.Delete(_L("\\TESTDIR\\NAME.EXT")))!=KErrInUse)
 
   490 	if ((c=TheFs.Delete(_L("\\TESTDIR\\NAME.EXT")))!=LockedErr)
 
   467 		Error(_L("Delete 502"),c);
 
   491 		Error(_L("Delete 502"),c);
 
   468 	gFile.Close();
 
   492 	gFile.Close();
 
   469 	if ((c=TheFs.Delete(_L("\\TESTDIR\\NAME.EXT")))!=KErrNone)
 
   493 	if ((c=TheFs.Delete(_L("\\TESTDIR\\NAME.EXT")))!=KErrNone)
 
   470 		Error(_L("Delete 503"),c);
 
   494 		Error(_L("Delete 503"),c);
 
   471 	if ((c=TheFs.RmDir(_L("\\TESTDIR\\")))!=KErrNone)
 
   495 	if ((c=TheFs.RmDir(_L("\\TESTDIR\\")))!=KErrNone)
 
   591         Error2(_L("Make directory 1"),c, line);
 
   615         Error2(_L("Make directory 1"),c, line);
 
   592     if (res==FALSE)
 
   616     if (res==FALSE)
 
   593 		{
 
   617 		{
 
   594         TParse parse;
 
   618         TParse parse;
 
   595         c=TheFs.Parse(aDirName,parse);
 
   619         c=TheFs.Parse(aDirName,parse);
 
   596         test_KErrNone(c);
 
   620         test(c==KErrNone);
 
   597         buf=parse.Path();
 
   621         buf=parse.Path();
 
   598         buf.Append(_L("*"));
 
   622         buf.Append(_L("*"));
 
   599         if (buf.Length()<=64)
 
   623         if (buf.Length()<=64)
 
   600 			{
 
   624 			{
 
   601             test.Printf(_L("Open dir...\n"));
 
   625             test.Printf(_L("Open dir...\n"));
 
   602             if ((c=gDir.Open(TheFs,buf,KEntryAttMaskSupported))!=KErrNone)
 
   626             if ((c=gDir.Open(TheFs,buf,KEntryAttMaskSupported))!=KErrNone)
 
   603                 Error2(_L("Directory open 1"),c, line);
 
   627                 Error2(_L("Directory open 1"),c, line);
 
   604             gDataBuf[0]=0;
 
   628             gDataBuf[0]=0;
 
   605             if ((c=gDir.Read(gFileEntry))!=KErrEof)
 
   629             if ((c=gDir.Read(gFileEntry))!=EofErr)
 
   606             	{
 
   630             	{
 
   607                 test.Printf(_L("buf=\"%S\"\n"),&gFileEntry.iName);
 
   631                 test.Printf(_L("buf=\"%S\"\n"),&gFileEntry.iName);
 
   608                 Error2(_L("Directory read"),c, line);
 
   632                 Error2(_L("Directory read"),c, line);
 
   609             	}
 
   633             	}
 
   610             gDir.Close();
 
   634             gDir.Close();
 
   687 
   711 
   688     //-- set up console output
 
   712     //-- set up console output
 
   689     F32_Test_Utils::SetConsole(test.Console());
 
   713     F32_Test_Utils::SetConsole(test.Console());
 
   690 
   714 
   691     TInt nRes=TheFs.CharToDrive(gDriveToTest, gDriveNum);
 
   715     TInt nRes=TheFs.CharToDrive(gDriveToTest, gDriveNum);
 
   692     test_KErrNone(nRes);
 
   716     test(nRes==KErrNone);
 
   693     
   717     
   694     PrintDrvInfo(TheFs, gDriveNum);
 
   718     PrintDrvInfo(TheFs, gDriveNum);
 
   695 
   719 
   696     //-- quick format the drive, if it isn't drive C: of the emulator or PlatSim
 
   720     //-- quick format the drive, if it isn't the emulator's C:  
   697     if(!Is_SimulatedSystemDrive(TheFs, gDriveNum))
 
   721     if(!Is_Win32(TheFs, gDriveNum))
 
   698     	{
 
   722     {
 
   699         nRes = FormatDrive(TheFs, gDriveNum, ETrue); 
   723         nRes = FormatDrive(TheFs, gDriveNum, ETrue); 
   700         test_KErrNone(nRes);
 
   724         test(nRes==KErrNone);
 
   701     	}
 
   725     }
 
   702 
   726 
   703     //-----------------------------------
 
   727     //-----------------------------------
 
   704 	TInt c;
 
   728 	TInt c;
 
   705 	TInt i,count;
 
   729 	TInt i,count;
 
   706 	TInt pos;
 
   730 	TInt pos;
 
   724 	testDir(_L("Z:\\"));
 
   748 	testDir(_L("Z:\\"));
 
   725 	testDir(_L("Z:\\*"));
 
   749 	testDir(_L("Z:\\*"));
 
   726 	testDir(_L("Z:\\*.*"));
 
   750 	testDir(_L("Z:\\*.*"));
 
   727 
   751 
   728 	test.Printf(_L("Test names containing '\\'\n"));
 
   752 	test.Printf(_L("Test names containing '\\'\n"));
 
   729 	if ((c=gFile.Create(TheFs,_L("Q\\ZZZ"),EFileWrite))!=KErrBadName)
 
   753 	if ((c=gFile.Create(TheFs,_L("Q\\ZZZ"),EFileWrite))!=NameErr)
 
   730 		Error(_L("Create 1"),c);
 
   754 		Error(_L("Create 1"),c);
 
   731 
   755 
   732 	test.Printf(_L("Test create in non-exist directory\n"));
 
   756 	test.Printf(_L("Test create in non-exist directory\n"));
 
   733 	if ((c=gFile.Create(TheFs,_L("\\Q1DDX\\ZZZ"),EFileWrite))!=KErrPathNotFound)
 
   757 	if ((c=gFile.Create(TheFs,_L("\\Q1DDX\\ZZZ"),EFileWrite))!=DirErr)
 
   734 		Error(_L("Create 2"),c);
 
   758 		Error(_L("Create 2"),c);
 
   735 
   759 
   736 	test.Printf(_L("Test filenames starting with '.'\n"));
 
   760 	test.Printf(_L("Test filenames starting with '.'\n"));
 
   737 	if ((c=gFile.Create(TheFs,_L("\\.ZZZ"),EFileWrite))!=KErrNone) // ****** KErrBadName)
 
   761 	if ((c=gFile.Create(TheFs,_L("\\.ZZZ"),EFileWrite))!=KErrNone) // ****** NameErr)
 
   738 		Error(_L("Create 3"),c);
 
   762 		Error(_L("Create 3"),c);
 
   739 	gFile.Close();
 
   763 	gFile.Close();
 
   740 	if ((c=TheFs.Delete(_L("\\.ZZZ")))!=KErrNone)
 
   764 	if ((c=TheFs.Delete(_L("\\.ZZZ")))!=KErrNone)
 
   741 		Error(_L("Delete 3"),c);
 
   765 		Error(_L("Delete 3"),c);
 
   742 
   766 
   800 	testUnique(EFileStream);
 
   824 	testUnique(EFileStream);
 
   801 	testUnique(EFileStreamText);
 
   825 	testUnique(EFileStreamText);
 
   802 	testDelete();
 
   826 	testDelete();
 
   803 	testRename();
 
   827 	testRename();
 
   804 	test.Printf(_L("Test get file info\n"));
 
   828 	test.Printf(_L("Test get file info\n"));
 
   805 //	testFileInfo(_L("*.*"),KErrBadName); ********** Allowed (?)
 
   829 //	testFileInfo(_L("*.*"),NameErr); ********** Allowed (?)
 
   806 	testFileInfo(_L(""),KErrNone); // KErrBadName);
 
   830 	testFileInfo(_L(""),KErrNone); // NameErr);
 
   807 	testFileInfo(_L("\\"),KErrBadName);
 
   831 	testFileInfo(_L("\\"),NameErr);
 
   808 	testFileInfo(_L("."),KErrBadName);
 
   832 	testFileInfo(_L("."),NameErr);
 
   809 	testFileInfo(_L(".."),KErrBadName);
 
   833 	testFileInfo(_L(".."),NameErr);
 
   810 	testFileInfo(_L("a.1234"),KErrNotFound); // ********* KErrBadName);
 
   834 	testFileInfo(_L("a.1234"),KErrNotFound); // ********* NameErr);
 
   811 	testFileInfo(_L("a23456789"),KErrNotFound); // ********* KErrBadName);
 
   835 	testFileInfo(_L("a23456789"),KErrNotFound); // ********* NameErr);
 
   812 	testFileInfo(_L(".a"),KErrNotFound); // ********** KErrBadName);
 
   836 	testFileInfo(_L(".a"),KErrNotFound); // ********** NameErr);
 
   813 	testFileInfo(_L("?"),KErrBadName);
 
   837 	testFileInfo(_L("?"),NameErr);
 
   814 	testFileInfo(_L("NOEXIST"),KErrNotFound);
 
   838 	testFileInfo(_L("NOEXIST"),NotExistsErr);
 
   815 	testFileInfo(_L("\\NODIR\\NAME"),KErrPathNotFound);
 
   839 	testFileInfo(_L("\\NODIR\\NAME"),DirErr);
 
   816 	testFileInfo(_L("L:\\NAME"),KErrNotReady);
 
   840 	testFileInfo(_L("L:\\NAME"),DeviceErr);
 
   817 	gNameBuf.SetLength(0);
 
   841 	gNameBuf.SetLength(0);
 
   818 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream))!=KErrNone)
 
   842 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream))!=KErrNone)
 
   819 		Error(_L("Open 1.1"),c);
 
   843 		Error(_L("Open 1.1"),c);
 
   820 	testFileInfo(gNameOut,FALSE);       // Not locked //
 
   844 	testFileInfo(gNameOut,FALSE);       // Not locked //
 
   821 	gFile.Close();
 
   845 	gFile.Close();
 
   823 	if ((c=TheFs.Delete(gNameOut))!=KErrNone)
 
   847 	if ((c=TheFs.Delete(gNameOut))!=KErrNone)
 
   824 		Error(_L("Delete"),c);
 
   848 		Error(_L("Delete"),c);
 
   825 
   849 
   826 	test.Printf(_L("Test get device info\n"));
 
   850 	test.Printf(_L("Test get device info\n"));
 
   827 	testDeviceInfo(_L(""),FALSE);           // NULL is current device //
 
   851 	testDeviceInfo(_L(""),FALSE);           // NULL is current device //
 
   828 	testDeviceInfo(_L("L:"),KErrNotReady);
 
   852 	testDeviceInfo(_L("L:"),DeviceErr);
 
   829 	testDeviceInfo(_L("Z:"),FALSE);
 
   853 	testDeviceInfo(_L("Z:"),FALSE);
 
   830 	testDeviceInfo(fBuf,FALSE);
 
   854 	testDeviceInfo(fBuf,FALSE);
 
   831 	
   855 	
   832 
   856 
   833 //	test.Printf(_L("Test get node info\n"));
 
   857 //	test.Printf(_L("Test get node info\n"));
 
   846 //	testNodeInfo(_L("XXX::"),0,E_GEN_FSYS);
 
   870 //	testNodeInfo(_L("XXX::"),0,E_GEN_FSYS);
 
   847 //	testNodeInfo(_L("REM::"),0,E_GEN_FSYS);
 
   871 //	testNodeInfo(_L("REM::"),0,E_GEN_FSYS);
 
   848 //	testNodeInfo(_L("...::"),0,E_GEN_FSYS);
 
   872 //	testNodeInfo(_L("...::"),0,E_GEN_FSYS);
 
   849 
   873 
   850 //	testFileInfo(_L("Z:SYS$WSRV.IMG"),FALSE);
 
   874 //	testFileInfo(_L("Z:SYS$WSRV.IMG"),FALSE);
 
   851 //	testFileInfo(_L("Z:\\SYS$WSRV.IMG"),KErrBadName);    // \ not allowed  - no path //
 
   875 //	testFileInfo(_L("Z:\\SYS$WSRV.IMG"),NameErr);    // \ not allowed  - no path //
 
   852 //	testFileInfo(_L("Z:*"),FALSE);               // Z: allows *'s ! //
 
   876 //	testFileInfo(_L("Z:*"),FALSE);               // Z: allows *'s ! //
 
   853 //	testFileInfo(_L("Z:SYS$WSRV."),KErrNotFound);
 
   877 //	testFileInfo(_L("Z:SYS$WSRV."),NotExistsErr);
 
   854 //	testFileInfo(_L("XXX::"),NoFileSystemErr);
 
   878 //	testFileInfo(_L("XXX::"),NoFileSystemErr);
 
   855 	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))
 
   879 	if(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin))
 
   856 		testFileInfo(_L("Z:\\Sys\\Bin\\ESHELL.EXE"),FALSE);    // we now have paths //
 
   880 		testFileInfo(_L("Z:\\Sys\\Bin\\ESHELL.EXE"),FALSE);    // we now have paths //
 
   857 	else
 
   881 	else
 
   858 		testFileInfo(_L("Z:\\System\\Bin\\ESHELL.EXE"),FALSE);    // we now have paths //
 
   882 		testFileInfo(_L("Z:\\System\\Bin\\ESHELL.EXE"),FALSE);    // we now have paths //
 
   859 //	testFileInfo(_L("Z:*"),KErrPathNotFound); // session path gets inserted ,FALSE);
 
   883 //	testFileInfo(_L("Z:*"),KErrPathNotFound); // session path gets inserted ,FALSE);
 
   860 //	testFileInfo(_L("Z:SYS$WSRV."),KErrNotFound);
 
   884 //	testFileInfo(_L("Z:SYS$WSRV."),NotExistsErr);
 
   861 //	testFileInfo(_L("H:"),KErrBadName); // ************** NoFileSystemErr);
 
   885 //	testFileInfo(_L("H:"),KErrBadName); // ************** NoFileSystemErr);
 
   862 
   886 
   863 	test.Printf(_L("Test weird filenames\n"));
 
   887 	test.Printf(_L("Test weird filenames\n"));
 
   864 // Test SPACES // 
   888 // Test SPACES // 
   865 
   889 
   866 	testFileName(_L("A B"),KErrNone); // ******* KErrBadName);
 
   890 	testFileName(_L("A B"),KErrNone); // ******* NameErr);
 
   867 	testFileName(_L(" AB"),KErrNone); // ******* KErrBadName);
 
   891 	testFileName(_L(" AB"),KErrNone); // ******* NameErr);
 
   868 	testFileName(_L(" AB      "),KErrNone); // ******* KErrBadName);
 
   892 	testFileName(_L(" AB      "),KErrNone); // ******* NameErr);
 
   869 	testFileName(_L("    AB"),KErrNone);
 
   893 	testFileName(_L("    AB"),KErrNone);
 
   870 	testFileName(_L(" AB  . cdef"),KErrNone);
 
   894 	testFileName(_L(" AB  . cdef"),KErrNone);
 
   871 	testFileName(_L(" AB  .  cdef  "),KErrNone);
 
   895 	testFileName(_L(" AB  .  cdef  "),KErrNone);
 
   872 	testFileName(_L("A2345678 "),KErrNone); // ******* KErrBadName);
 
   896 	testFileName(_L("A2345678 "),KErrNone); // ******* NameErr);
 
   873 	testFileName(_L("A2345678.XY "),KErrNone); // ******* KErrBadName);
 
   897 	testFileName(_L("A2345678.XY "),KErrNone); // ******* NameErr);
 
   874 	testFileName(_L("A2345678.XYZ "),KErrNone); // ******* KErrBadName);
 
   898 	testFileName(_L("A2345678.XYZ "),KErrNone); // ******* NameErr);
 
   875 	testFileName(_L("A2345678 XYZ"),KErrNone); // ******* KErrBadName);
 
   899 	testFileName(_L("A2345678 XYZ"),KErrNone); // ******* NameErr);
 
   876 	testFileName(_L(" "),KErrBadName);
 
   900 	testFileName(_L(" "),NameErr);
 
   877 	testFileName(_L("\\A B\\NAME"),KErrPathNotFound); // ******* KErrBadName);
 
   901 	testFileName(_L("\\A B\\NAME"),KErrPathNotFound); // ******* NameErr);
 
   878 	testFileName(_L("\\ \\NAME"),KErrBadName);
 
   902 	testFileName(_L("\\ \\NAME"),NameErr);
 
   879 	testFileName(_L("\\asdf\\qer\\   \\asdf\\NAME"),KErrBadName);
 
   903 	testFileName(_L("\\asdf\\qer\\   \\asdf\\NAME"),NameErr);
 
   880 	testFileName(_L("     "),KErrBadName);
 
   904 	testFileName(_L("     "),NameErr);
 
   881 	testFileName(_L("C:\\asdf\\     "),KErrBadName);
 
   905 	testFileName(_L("C:\\asdf\\     "),NameErr);
 
   882 // Test short names //
 
   906 // Test short names //
 
   883 	testFileName(_L(""),KErrBadName);
 
   907 	testFileName(_L(""),NameErr);
 
   884 	testFileName(_L("\\"),KErrBadName);
 
   908 	testFileName(_L("\\"),NameErr);
 
   885 	testFileName(_L("1"),FALSE);
 
   909 	testFileName(_L("1"),FALSE);
 
   886 	testFileName(_L(".1"),KErrNone); // ******* KErrBadName);
 
   910 	testFileName(_L(".1"),KErrNone); // ******* NameErr);
 
   887 	testFileName(_L(".1"),KErrNone); // ******* KErrBadName);
 
   911 	testFileName(_L(".1"),KErrNone); // ******* NameErr);
 
   888 	testFileName(_L("\\.1"),KErrNone); // ******* KErrBadName);
 
   912 	testFileName(_L("\\.1"),KErrNone); // ******* NameErr);
 
   889 	testFileName(_L("1.1"),FALSE);
 
   913 	testFileName(_L("1.1"),FALSE);
 
   890 // Test long names //
 
   914 // Test long names //
 
   891 	testFileName(_L("12345678.123"),FALSE);
 
   915 	testFileName(_L("12345678.123"),FALSE);
 
   892 	testFileName(_L("123456789.123"),KErrNone); // ******* KErrBadName);
 
   916 	testFileName(_L("123456789.123"),KErrNone); // ******* NameErr);
 
   893 	testFileName(_L("12345678.1234"),KErrNone); // ******* KErrBadName);
 
   917 	testFileName(_L("12345678.1234"),KErrNone); // ******* NameErr);
 
   894 	testFileName(_L("1.1234"),KErrNone); // ******* KErrBadName);
 
   918 	testFileName(_L("1.1234"),KErrNone); // ******* NameErr);
 
   895 	testFileName(_L("123456789"),KErrNone); // ******* KErrBadName);
 
   919 	testFileName(_L("123456789"),KErrNone); // ******* NameErr);
 
   896 	gDataBuf.SetLength(256);
 
   920 	gDataBuf.SetLength(256);
 
   897 	gDataBuf.Fill('A',255);
 
   921 	gDataBuf.Fill('A',255);
 
   898 	testFileName(gDataBuf,KErrBadName);
 
   922 	testFileName(gDataBuf,NameErr);
 
   899 	gDataBuf.SetLength(257);
 
   923 	gDataBuf.SetLength(257);
 
   900 	gDataBuf.Fill('B',256);
 
   924 	gDataBuf.Fill('B',256);
 
   901 	testFileName(gDataBuf,KErrBadName);
 
   925 	testFileName(gDataBuf,NameErr);
 
   902 	gDataBuf.SetLength(258);
 
   926 	gDataBuf.SetLength(258);
 
   903 	gDataBuf.Fill('C',257);
 
   927 	gDataBuf.Fill('C',257);
 
   904 	testFileName(gDataBuf,KErrBadName);
 
   928 	testFileName(gDataBuf,NameErr);
 
   905 	gDataBuf.SetLength(4096);
 
   929 	gDataBuf.SetLength(4096);
 
   906 	gDataBuf.Fill('D',4095);
 
   930 	gDataBuf.Fill('D',4095);
 
   907 	testFileName(gDataBuf,KErrBadName);
 
   931 	testFileName(gDataBuf,NameErr);
 
   908 // Test DOTS //
 
   932 // Test DOTS //
 
   909 	testFileName(_L("A.X"),FALSE);
 
   933 	testFileName(_L("A.X"),FALSE);
 
   910 	testFileName(_L("A..X"),KErrNone); // ******* KErrBadName);
 
   934 	testFileName(_L("A..X"),KErrNone); // ******* NameErr);
 
   911 	testFileName(_L("A.........X"),KErrNone); // ******* KErrBadName);
 
   935 	testFileName(_L("A.........X"),KErrNone); // ******* NameErr);
 
   912 	testFileName(_L("A."),FALSE);
 
   936 	testFileName(_L("A."),FALSE);
 
   913 	testFileName(_L(".X"),KErrNone); // ******* KErrBadName);
 
   937 	testFileName(_L(".X"),KErrNone); // ******* NameErr);
 
   914 	testFileName(_L("."),KErrBadName);
 
   938 	testFileName(_L("."),NameErr);
 
   915 	testFileName(_L(".."),KErrBadName);
 
   939 	testFileName(_L(".."),NameErr);
 
   916 //	testFileName(_L("..."),KErrNone); // KErrBadName); // !!! ********* NT error KErrAccessDenied (?)
 
   940 //	testFileName(_L("..."),KErrNone); // NameErr); // !!! ********* NT error KErrAccessDenied (?)
 
   917 	testFileName(_L("\\a.x\\NAME"),KErrPathNotFound); // KErrPathNotFound == KErrPathNotFound
 
   941 	testFileName(_L("\\a.x\\NAME"),DirErr); // DirErr == KErrPathNotFound
 
   918 	testFileName(_L("\\a..x\\NAME"),KErrPathNotFound); // ******** KErrBadName);
 
   942 	testFileName(_L("\\a..x\\NAME"),DirErr); // ******** NameErr);
 
   919 	testFileName(_L("\\.\\NAME"),KErrBadName);
 
   943 	testFileName(_L("\\.\\NAME"),NameErr);
 
   920 	testFileName(_L("\\..\\NAME"),KErrBadName);
 
   944 	testFileName(_L("\\..\\NAME"),NameErr);
 
   921 //	testFileName(_L("\\...\\NAME"),KErrPathNotFound); // ******** KErrBadName); // !! NT treats ... as .. ??
 
   945 //	testFileName(_L("\\...\\NAME"),KErrPathNotFound); // ******** NameErr); // !! NT treats ... as .. ??
 
   922 // Test WILD CARDS //
 
   946 // Test WILD CARDS //
 
   923 	testFileName(_L("*.*"),KErrBadName);
 
   947 	testFileName(_L("*.*"),NameErr);
 
   924 	testFileName(_L("*"),KErrBadName);
 
   948 	testFileName(_L("*"),NameErr);
 
   925 	testFileName(_L("\\*"),KErrBadName);
 
   949 	testFileName(_L("\\*"),NameErr);
 
   926 	testFileName(_L("?"),KErrBadName);
 
   950 	testFileName(_L("?"),NameErr);
 
   927 	testFileName(_L("\\?"),KErrBadName);
 
   951 	testFileName(_L("\\?"),NameErr);
 
   928 	testFileName(_L("\\A?B\\NAME"),KErrBadName);
 
   952 	testFileName(_L("\\A?B\\NAME"),NameErr);
 
   929 	testFileName(_L("\\A*B\\NAME"),KErrBadName);
 
   953 	testFileName(_L("\\A*B\\NAME"),NameErr);
 
   930 	testFileName(_L("\\*\\NAME"),KErrBadName);
 
   954 	testFileName(_L("\\*\\NAME"),NameErr);
 
   931 	testFileName(_L("\\********.***\\NAME"),KErrBadName);
 
   955 	testFileName(_L("\\********.***\\NAME"),NameErr);
 
   932 	testFileName(_L("A?X"),KErrBadName);
 
   956 	testFileName(_L("A?X"),NameErr);
 
   933 
   957 
   934 	test.Printf(_L("Test set volume name\n"));
 
   958 	test.Printf(_L("Test set volume name\n"));
 
   935 // New behaviour: SetVolumeName accepts any string < 12 chars
 
   959 // New behaviour: SetVolumeName accepts any string < 12 chars
 
   936 // No modifications are made on the string.
 
   960 // No modifications are made on the string.
 
   937 #if defined(__WINS__)
 
   961 #if defined(__WINS__)
 
   992 		
  1016 		
   993 	test.Printf(_L("Test make directory\n"));
 
  1017 	test.Printf(_L("Test make directory\n"));
 
   994 
  1018 
   995 // Test path 
  1019 // Test path 
   996 	testMakeDir(_L("\\A2345678.A23\\NAME"),FALSE);
 
  1020 	testMakeDir(_L("\\A2345678.A23\\NAME"),FALSE);
 
   997 	testMakeDir(_L("\\A23456789.A23\\NAME"),KErrNone); // ******** KErrBadName);
 
  1021 	testMakeDir(_L("\\A23456789.A23\\NAME"),KErrNone); // ******** NameErr);
 
   998 	testMakeDir(_L("\\A2345678.A234\\NAME"),KErrNone); // ******** KErrBadName);
 
  1022 	testMakeDir(_L("\\A2345678.A234\\NAME"),KErrNone); // ******** NameErr);
 
   999 	testMakeDir(_L("\\A.1234\\NAME"),KErrNone); // ********* KErrBadName);
 
  1023 	testMakeDir(_L("\\A.1234\\NAME"),KErrNone); // ********* NameErr);
 
  1000 	testMakeDir(_L("\\A2345678\\NAME"),FALSE);
 
  1024 	testMakeDir(_L("\\A2345678\\NAME"),FALSE);
 
  1001 	testMakeDir(_L("\\A23456789\\NAME"),KErrNone); // ******** KErrBadName);
 
  1025 	testMakeDir(_L("\\A23456789\\NAME"),KErrNone); // ******** NameErr);
 
  1002 	testMakeDir(_L("\\A.X\\NAME"),FALSE);
 
  1026 	testMakeDir(_L("\\A.X\\NAME"),FALSE);
 
  1003 	testMakeDir(_L("\\A..X\\NAME"),KErrNone); // ******** KErrBadName);
 
  1027 	testMakeDir(_L("\\A..X\\NAME"),KErrNone); // ******** NameErr);
 
  1004 	testMakeDir(_L("\\A.\\NAME"),KErrBadName);
 
  1028 	testMakeDir(_L("\\A.\\NAME"),NameErr);
 
  1005 	testMakeDir(_L("\\.X\\NAME"),KErrNone); // ******** KErrBadName);
 
  1029 	testMakeDir(_L("\\.X\\NAME"),KErrNone); // ******** NameErr);
 
  1006 	testMakeDir(_L("\\.\\NAME"),KErrBadName);
 
  1030 	testMakeDir(_L("\\.\\NAME"),NameErr);
 
  1007 	testMakeDir(_L("\\..\\NAME"),KErrBadName);
 
  1031 	testMakeDir(_L("\\..\\NAME"),NameErr);
 
  1008 	testMakeDir(_L("\\\\NAME"),KErrBadName);
 
  1032 	testMakeDir(_L("\\\\NAME"),NameErr);
 
  1009 	testMakeDir(_L("\\\\"),KErrBadName);
 
  1033 	testMakeDir(_L("\\\\"),NameErr);
 
  1010 	testMakeDir(_L("\\A\\A2\\A23\\a2345678\\a2345678.\\a2345678.1\\a2345678.123"),KErrBadName);
 
  1034 	testMakeDir(_L("\\A\\A2\\A23\\a2345678\\a2345678.\\a2345678.1\\a2345678.123"),NameErr);
 
  1011 	testMakeDir(_L("\\A\\A2\\A23\\a2345678\\a2345678.\\a2345678.1\\a2345678..123"),KErrBadName); // ******* KErrBadName);
 
  1035 	testMakeDir(_L("\\A\\A2\\A23\\a2345678\\a2345678.\\a2345678.1\\a2345678..123"),NameErr); // ******* NameErr);
 
  1012 	testMakeDir(_L("\\A\\A2\\A23\\a2345678\\a2345678.\\a2345678.1\\a2345678.1234"),KErrBadName); // ******* KErrBadName);
 
  1036 	testMakeDir(_L("\\A\\A2\\A23\\a2345678\\a2345678.\\a2345678.1\\a2345678.1234"),NameErr); // ******* NameErr);
 
  1013 	gDataBuf.SetLength(256);
 
  1037 	gDataBuf.SetLength(256);
 
  1014 	gDataBuf.Fill('V',255);
 
  1038 	gDataBuf.Fill('V',255);
 
  1015 	testMakeDir(gDataBuf,KErrBadName);
 
  1039 	testMakeDir(gDataBuf,NameErr);
 
  1016 	gDataBuf.SetLength(257);
 
  1040 	gDataBuf.SetLength(257);
 
  1017 	gDataBuf.Fill('W',256);
 
  1041 	gDataBuf.Fill('W',256);
 
  1018 	testMakeDir(gDataBuf,KErrBadName);
 
  1042 	testMakeDir(gDataBuf,NameErr);
 
  1019 	gDataBuf.SetLength(258);
 
  1043 	gDataBuf.SetLength(258);
 
  1020 	gDataBuf.Fill('X',257);
 
  1044 	gDataBuf.Fill('X',257);
 
  1021 	testMakeDir(gDataBuf,KErrBadName);
 
  1045 	testMakeDir(gDataBuf,NameErr);
 
  1022 	gDataBuf.SetLength(259);
 
  1046 	gDataBuf.SetLength(259);
 
  1023 	gDataBuf.Fill('Y',258);
 
  1047 	gDataBuf.Fill('Y',258);
 
  1024 	testMakeDir(gDataBuf,KErrBadName);
 
  1048 	testMakeDir(gDataBuf,NameErr);
 
  1025 	gDataBuf.SetLength(4096);
 
  1049 	gDataBuf.SetLength(4096);
 
  1026 	gDataBuf.Fill('Z',4095);
 
  1050 	gDataBuf.Fill('Z',4095);
 
  1027 	testMakeDir(gDataBuf,KErrBadName);
 
  1051 	testMakeDir(gDataBuf,NameErr);
 
  1028 
  1052 
  1029 // Test names 
  1053 // Test names 
  1030 	testMakeDir(_L("A..X"),KErrAlreadyExists); // ******* KErrBadName);
 
  1054 	testMakeDir(_L("A..X"),KErrAlreadyExists); // ******* NameErr);
 
  1031 	testMakeDir(_L("\\A\\"),FALSE);
 
  1055 	testMakeDir(_L("\\A\\"),FALSE);
 
  1032 	testMakeDir(_L("\\12345678.123\\"),FALSE);
 
  1056 	testMakeDir(_L("\\12345678.123\\"),FALSE);
 
  1033 	testMakeDir(_L("\\.\\"),KErrBadName);
 
  1057 	testMakeDir(_L("\\.\\"),NameErr);
 
  1034 	testMakeDir(_L("\\..\\"),KErrBadName);
 
  1058 	testMakeDir(_L("\\..\\"),NameErr);
 
  1035 	testMakeDir(_L("\\X\\"),FALSE);
 
  1059 	testMakeDir(_L("\\X\\"),FALSE);
 
  1036 	testMakeDir(_L("\\12345678.1234\\"),KErrNone); // ******* KErrBadName);
 
  1060 	testMakeDir(_L("\\12345678.1234\\"),KErrNone); // ******* NameErr);
 
  1037 	testMakeDir(_L("\\123456789\\"),KErrNone); // ******** KErrBadName);
 
  1061 	testMakeDir(_L("\\123456789\\"),KErrNone); // ******** NameErr);
 
  1038 // Test max levels
 
  1062 // Test max levels
 
  1039 	testMakeDir(_L("\\A\\B\\C\\D\\E\\F\\G\\H\\I\\J\\K\\L\\M\\N\\O\\P\\Q\\R\\S\\T\\U\\V\\W\\X\\Y\\Z"),FALSE);
 
  1063 	testMakeDir(_L("\\A\\B\\C\\D\\E\\F\\G\\H\\I\\J\\K\\L\\M\\N\\O\\P\\Q\\R\\S\\T\\U\\V\\W\\X\\Y\\Z"),FALSE);
 
  1040 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.3"),FALSE);
 
  1064 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.3"),FALSE);
 
  1041 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.34"),FALSE);
 
  1065 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.34"),FALSE);
 
  1042 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.345"),FALSE);
 
  1066 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.345"),FALSE);
 
  1043 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.3\\xxxxxxxx.xxx"),FALSE);
 
  1067 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.3\\xxxxxxxx.xxx"),FALSE);
 
  1044 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.34\\xxxxxxxx.xxx"),KErrNone); // ******* KErrBadName);
 
  1068 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.34\\xxxxxxxx.xxx"),KErrNone); // ******* NameErr);
 
  1045 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.345\\xxxxxxxx.xxx"),KErrNone); // ******* KErrBadName);
 
  1069 	testMakeDir(_L("\\00000000.000\\11111111.111\\22222222.222\\33333333.333\\45678901.345\\xxxxxxxx.xxx"),KErrNone); // ******* NameErr);
 
  1046 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\23"),FALSE);
 
  1070 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\23"),FALSE);
 
  1047 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\23456789.123"),FALSE);
 
  1071 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\23456789.123"),FALSE);
 
  1048 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\23\\5"),FALSE);
 
  1072 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\23\\5"),FALSE);
 
  1049 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\23\\56789012.456"),FALSE);
 
  1073 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\23\\56789012.456"),FALSE);
 
  1050 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\234\\6"),KErrNone); // ******** KErrBadName);
 
  1074 	testMakeDir(_L("\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\2\\4\\6\\8\\0\\234\\6"),KErrNone); // ******** NameErr);
 
  1051 	testMakeDir(_L("Z:\\ROMDIR\\"),KErrAccessDenied); //
 
  1075 	testMakeDir(_L("Z:\\ROMDIR\\"),KErrAccessDenied); // *********** NotSupportedErr);
 
  1052 	test.Printf(_L("Test setEof to same length\n"));
 
  1076 	test.Printf(_L("Test setEof to same length\n"));
 
  1053 	gNameBuf.SetLength(0);
 
  1077 	gNameBuf.SetLength(0);
 
  1054 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream|EFileWrite))!=KErrNone)
 
  1078 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream|P_FUPDATE))!=KErrNone)
 
  1055 		Error(_L("Open 50"),c);
 
  1079 		Error(_L("Open 50"),c);
 
  1056 	gFile.Close();
 
  1080 	gFile.Close();
 
  1057 	testSetEof(gNameOut,0L,FALSE);  // should be no change //
 
  1081 	testSetEof(gNameOut,0L,FALSE);  // should be no change //
 
  1058 	testSetEof(gNameOut,1L,TRUE);   // should be change //
 
  1082 	testSetEof(gNameOut,1L,TRUE);   // should be change //
 
  1059 	testSetEof(gNameOut,1L,FALSE);  // should be no change //
 
  1083 	testSetEof(gNameOut,1L,FALSE);  // should be no change //
 
  1073 		Error(_L("Delete"),c);
 
  1097 		Error(_L("Delete"),c);
 
  1074 
  1098 
  1075 	test.Printf(_L("Test read of zero bytes\n"));
 
  1099 	test.Printf(_L("Test read of zero bytes\n"));
 
  1076 	gNameBuf.SetLength(0);
 
  1100 	gNameBuf.SetLength(0);
 
  1077 
  1101 
  1078 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream|EFileWrite))!=KErrNone)
 
  1102 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream|P_FUPDATE))!=KErrNone)
 
  1079 		Error(_L("Open 60"),c);
 
  1103 		Error(_L("Open 60"),c);
 
  1080 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** KErrEof)
 
  1104 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** EofErr)
 
  1081 		Error(_L("Read 61"),c);
 
  1105 		Error(_L("Read 61"),c);
 
  1082 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** KErrEof)
 
  1106 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** EofErr)
 
  1083 		Error(_L("Read 62"),c);
 
  1107 		Error(_L("Read 62"),c);
 
  1084 	if ((c=gFile.Write(gDataBuf,0))!=KErrNone)
 
  1108 	if ((c=gFile.Write(gDataBuf,0))!=KErrNone)
 
  1085 		Error(_L("Write 63"),c);
 
  1109 		Error(_L("Write 63"),c);
 
  1086 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** KErrEof)
 
  1110 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** EofErr)
 
  1087 		Error(_L("Read 64"),c);
 
  1111 		Error(_L("Read 64"),c);
 
  1088 	gFile.Close();
 
  1112 	gFile.Close();
 
  1089 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|EFileWrite))!=KErrNone)
 
  1113 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|P_FUPDATE|P_FRANDOM))!=KErrNone)
 
  1090 		Error(_L("Open 70"),c);
 
  1114 		Error(_L("Open 70"),c);
 
  1091 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** KErrEof)
 
  1115 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** EofErr)
 
  1092 		Error(_L("Read 71"),c);
 
  1116 		Error(_L("Read 71"),c);
 
  1093 	gDataBuf.SetLength(1);
 
  1117 	gDataBuf.SetLength(1);
 
  1094 	gDataBuf[0]=0xf0;
 
  1118 	gDataBuf[0]=0xf0;
 
  1095 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1119 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1096 		Error(_L("Write 72"),c);
 
  1120 		Error(_L("Write 72"),c);
 
  1097 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ********* KErrEof)
 
  1121 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ********* EofErr)
 
  1098 		Error(_L("Read 73"),c);
 
  1122 		Error(_L("Read 73"),c);
 
  1099 	pos=0L;
 
  1123 	pos=0L;
 
  1100 	if ((c=gFile.Seek((TSeek)ESeekStart,pos))!=KErrNone)
 
  1124 	if ((c=gFile.Seek((TSeek)P_FABS,pos))!=KErrNone)
 
  1101 		Error(_L("Seek 74"),c);
 
  1125 		Error(_L("Seek 74"),c);
 
  1102 	gDataBuf.SetLength(1);
 
  1126 	gDataBuf.SetLength(1);
 
  1103 	gDataBuf[0]=0x83;
 
  1127 	gDataBuf[0]=0x83;
 
  1104 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone)
 
  1128 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone)
 
  1105 		Error(_L("Read 75"),c);
 
  1129 		Error(_L("Read 75"),c);
 
  1110 		Error(_L("Read 76"),c);
 
  1134 		Error(_L("Read 76"),c);
 
  1111 	if ((c=gFile.Read(gDataBuf,1))!=KErrNone || gDataBuf.Length()!=1)
 
  1135 	if ((c=gFile.Read(gDataBuf,1))!=KErrNone || gDataBuf.Length()!=1)
 
  1112 		Error(_L("Read 77"),c);
 
  1136 		Error(_L("Read 77"),c);
 
  1113 	if (gDataBuf[0]!=0xf0)
 
  1137 	if (gDataBuf[0]!=0xf0)
 
  1114 		Error(_L("buffer 1 check"),0);
 
  1138 		Error(_L("buffer 1 check"),0);
 
  1115 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** KErrEof)
 
  1139 	if ((c=gFile.Read(gDataBuf,0))!=KErrNone) // ******** EofErr)
 
  1116 		Error(_L("Read 78"),c);
 
  1140 		Error(_L("Read 78"),c);
 
  1117 	if ((c=gFile.Read(gDataBuf,16384))!=KErrNone) // ******* KErrEof)
 
  1141 	if ((c=gFile.Read(gDataBuf,16384))!=KErrNone) // ******* EofErr)
 
  1118 		Error(_L("Read 79"),c);
 
  1142 		Error(_L("Read 79"),c);
 
  1119 	gFile.Close();
 
  1143 	gFile.Close();
 
  1120 	if ((c=TheFs.Delete(gNameOut))!=KErrNone)
 
  1144 	if ((c=TheFs.Delete(gNameOut))!=KErrNone)
 
  1121 		Error(_L("Delete"),c);
 
  1145 		Error(_L("Delete"),c);
 
  1122 
  1146 
  1123     test.Printf(_L("Test write of zero bytes\n"));
 
  1147     test.Printf(_L("Test write of zero bytes\n"));
 
  1124     gNameBuf.SetLength(0);
 
  1148     gNameBuf.SetLength(0);
 
  1125     if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream|EFileWrite))!=KErrNone)
 
  1149     if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream|P_FUPDATE))!=KErrNone)
 
  1126         Error(_L("Open 50"),c);
 
  1150         Error(_L("Open 50"),c);
 
  1127     gFile.Close();
 
  1151     gFile.Close();
 
  1128 //	********** Error(_L("Close"),c); close has no return value
 
  1152 //	********** Error(_L("Close"),c); close has no return value
 
  1129 	gDataBuf.SetLength(16384);
 
  1153 	gDataBuf.SetLength(16384);
 
  1130 
  1154 
  1140     if ((c=TheFs.Delete(gNameOut))!=KErrNone)
 
  1164     if ((c=TheFs.Delete(gNameOut))!=KErrNone)
 
  1141         Error(_L("Delete"),c);
 
  1165         Error(_L("Delete"),c);
 
  1142 
  1166 
  1143 	test.Printf(_L("Test ReadOnly files\n"));
 
  1167 	test.Printf(_L("Test ReadOnly files\n"));
 
  1144 	gNameBuf.SetLength(0);
 
  1168 	gNameBuf.SetLength(0);
 
  1145 	if ((c=gFile.Create(TheFs,_L("TEST1.TMP"),EFileStream|EFileWrite))!=KErrNone)
 
  1169 	if ((c=gFile.Create(TheFs,_L("TEST1.TMP"),EFileStream|P_FUPDATE))!=KErrNone)
 
  1146 		Error(_L("Create 40"),c);
 
  1170 		Error(_L("Create 40"),c);
 
  1147 	gFile.Close();
 
  1171 	gFile.Close();
 
  1148 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream|EFileWrite))!=KErrNone)
 
  1172 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream|P_FUPDATE))!=KErrNone)
 
  1149 		Error(_L("Open 40"),c);
 
  1173 		Error(_L("Open 40"),c);
 
  1150 	mask=0;
 
  1174 	mask=0;
 
  1151 	attrib=KEntryAttReadOnly;                       // Remove writable //
 
  1175 	attrib=KEntryAttReadOnly;                       // Remove writable //
 
  1152 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=KErrInUse)
 
  1176 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=LockedErr)
 
  1153 		Error(_L("TheFs.SetAtt not locked"),c);
 
  1177 		Error(_L("TheFs.SetAtt not locked"),c);
 
  1154 	gFile.Close();
 
  1178 	gFile.Close();
 
  1155 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=KErrNone)
 
  1179 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=KErrNone)
 
  1156 		Error(_L("Att 41"),c);
 
  1180 		Error(_L("Att 41"),c);
 
  1157 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|EFileWrite))!=KErrAccessDenied)
 
  1181 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|P_FUPDATE))!=AccessErr)
 
  1158 		Error(_L("Open 41"),c);
 
  1182 		Error(_L("Open 41"),c);
 
  1159 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream))!=KErrNone)
 
  1183 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream))!=KErrNone)
 
  1160 		Error(_L("Open 42"),c);
 
  1184 		Error(_L("Open 42"),c);
 
  1161 	if ((c=gFileErr.Open(TheFs,gNameOut,EFileStream))!=KErrInUse)
 
  1185 	if ((c=gFileErr.Open(TheFs,gNameOut,EFileStream))!=LockedErr)
 
  1162 		Error(_L("Open 43"),c);
 
  1186 		Error(_L("Open 43"),c);
 
  1163 	if ((c=TheFs.Rename(_L("TEST1.TMP"),gNameOut))!=KErrAlreadyExists)
 
  1187 	if ((c=TheFs.Rename(_L("TEST1.TMP"),gNameOut))!=ExistsErr)
 
  1164 		Error(_L("Rename 43.1"),c);
 
  1188 		Error(_L("Rename 43.1"),c);
 
  1165 	if ((c=gFileErr.Create(TheFs,gNameOut,EFileStream))!=KErrAlreadyExists) // KErrInUse)
 
  1189 	if ((c=gFileErr.Create(TheFs,gNameOut,EFileStream))!=ExistsErr) // LockedErr)
 
  1166 		Error(_L("Open 44"),c);
 
  1190 		Error(_L("Open 44"),c);
 
  1167 	if ((c=gFileErr.Replace(TheFs,gNameOut,EFileStream))!=KErrInUse)
 
  1191 	if ((c=gFileErr.Replace(TheFs,gNameOut,EFileStream))!=LockedErr)
 
  1168 		Error(_L("Open 45"),c);
 
  1192 		Error(_L("Open 45"),c);
 
  1169 	gFile.Close();
 
  1193 	gFile.Close();
 
  1170 	if ((c=gFile.Create(TheFs,gNameOut,EFileStream))!=KErrAlreadyExists)
 
  1194 	if ((c=gFile.Create(TheFs,gNameOut,EFileStream))!=ExistsErr)
 
  1171 		Error(_L("Create 46"),c);
 
  1195 		Error(_L("Create 46"),c);
 
  1172 	if ((c=gFile.Replace(TheFs,gNameOut,EFileStream))!=KErrAccessDenied)
 
  1196 	if ((c=gFile.Replace(TheFs,gNameOut,EFileStream))!=AccessErr)
 
  1173 		Error(_L("Replace 47"),c);
 
  1197 		Error(_L("Replace 47"),c);
 
  1174 	if ((c=gFile.Create(TheFs,_L("FILE1.TMP"),EFileStream))!=KErrNone)
 
  1198 	if ((c=gFile.Create(TheFs,_L("FILE1.TMP"),EFileStream))!=KErrNone)
 
  1175 		Error(_L("Create 48"),c);
 
  1199 		Error(_L("Create 48"),c);
 
  1176 	if ((c=TheFs.Rename(_L("FILE1.TMP"),_L("FILE2.TMP")))!=KErrInUse)
 
  1200 	if ((c=TheFs.Rename(_L("FILE1.TMP"),_L("FILE2.TMP")))!=LockedErr)
 
  1177 		Error(_L("Rename 49"),c);
 
  1201 		Error(_L("Rename 49"),c);
 
  1178 	gFile.Close();
 
  1202 	gFile.Close();
 
  1179 	if ((c=TheFs.Rename(_L("FILE1.TMP"),_L("FILE2.TMP")))!=KErrNone)
 
  1203 	if ((c=TheFs.Rename(_L("FILE1.TMP"),_L("FILE2.TMP")))!=KErrNone)
 
  1180 		Error(_L("Rename 50"),c);
 
  1204 		Error(_L("Rename 50"),c);
 
  1181 	if ((c=TheFs.Rename(_L("FILE2.TMP"),gNameOut))!=KErrAlreadyExists)
 
  1205 	if ((c=TheFs.Rename(_L("FILE2.TMP"),gNameOut))!=ExistsErr)
 
  1182 		Error(_L("Rename 51"),c);
 
  1206 		Error(_L("Rename 51"),c);
 
  1183 	if ((c=TheFs.Delete(gNameOut))!=KErrAccessDenied)
 
  1207 	if ((c=TheFs.Delete(gNameOut))!=AccessErr)
 
  1184 		Error(_L("Delete"),c);
 
  1208 		Error(_L("Delete"),c);
 
  1185 	mask=KEntryAttReadOnly;
 
  1209 	mask=KEntryAttReadOnly;
 
  1186 	attrib=0;
 
  1210 	attrib=0;
 
  1187 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=KErrNone)
 
  1211 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=KErrNone)
 
  1188 		Error(_L("Att 42"),c);
 
  1212 		Error(_L("Att 42"),c);
 
  1198 		Error(_L("Open 30"),c);
 
  1222 		Error(_L("Open 30"),c);
 
  1199 	gFile.Close();
 
  1223 	gFile.Close();
 
  1200 	if ((c=gFile.Open(TheFs,_L("B_GEN.001"),EFileStream))!=KErrNone)
 
  1224 	if ((c=gFile.Open(TheFs,_L("B_GEN.001"),EFileStream))!=KErrNone)
 
  1201 		Error(_L("Open 30"),c);
 
  1225 		Error(_L("Open 30"),c);
 
  1202 	pos=1L;
 
  1226 	pos=1L;
 
  1203 	if ((c=gFile.SetSize(pos))!=KErrAccessDenied)
 
  1227 	if ((c=gFile.SetSize(pos))!=ReadOnlyErr)
 
  1204 		Error(_L("Set EOF 30"),c);
 
  1228 		Error(_L("Set EOF 30"),c);
 
  1205 	if ((c=TheFs.Entry(_L("B_GEN.001"),gFileEntry))!=KErrNone)
 
  1229 	if ((c=TheFs.Entry(_L("B_GEN.001"),gFileEntry))!=KErrNone)
 
  1206 		Error(_L("File info 30"),c);
 
  1230 		Error(_L("File info 30"),c);
 
  1207 	if (gFileEntry.iSize!=0L)
 
  1231 	if (gFileEntry.iSize!=0L)
 
  1208 		Error(_L("Size check 30"),0);
 
  1232 		Error(_L("Size check 30"),0);
 
  1209 	if ((c=gFile.Write(gDataBuf,1))!=KErrAccessDenied)
 
  1233 	if ((c=gFile.Write(gDataBuf,1))!=ReadOnlyErr)
 
  1210 		Error(_L("Write 30"),c);
 
  1234 		Error(_L("Write 30"),c);
 
  1211 	if ((c=TheFs.Entry(_L("B_GEN.001"),gFileEntry))!=KErrNone)
 
  1235 	if ((c=TheFs.Entry(_L("B_GEN.001"),gFileEntry))!=KErrNone)
 
  1212 		Error(_L("File info 31"),c);
 
  1236 		Error(_L("File info 31"),c);
 
  1213 	if (gFileEntry.iSize!=0L)
 
  1237 	if (gFileEntry.iSize!=0L)
 
  1214 		Error(_L("Size check 31"),0);
 
  1238 		Error(_L("Size check 31"),0);
 
  1221 		Error(_L("Delete"),c);
 
  1245 		Error(_L("Delete"),c);
 
  1222 
  1246 
  1223 
  1247 
  1224 	test.Printf(_L("Test dir entries are written out\n"));
 
  1248 	test.Printf(_L("Test dir entries are written out\n"));
 
  1225 	gNameBuf.SetLength(0);
 
  1249 	gNameBuf.SetLength(0);
 
  1226 	
  1250 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream|P_FRANDOM))!=KErrNone)
 
  1227     if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream))!=KErrNone)
 
       
  1228 		Error(_L("Open 20"),c); 
  1251 		Error(_L("Open 20"),c); 
  1229 	
       
  1230 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1252 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1231 		Error(_L("File info 0"),c);
 
  1253 		Error(_L("File info 0"),c);
 
  1232 	
  1254 	if ((gFileEntry.iAtt & P_FAMOD)==0)
 
  1233     if ((gFileEntry.iAtt & KEntryAttArchive)==0)
 
       
  1234 		Error(_L("Status 20"),0);
 
  1255 		Error(_L("Status 20"),0);
 
  1235 	
       
  1236 	test.Printf(_L("Size=%u\n"),gFileEntry.iSize);
 
  1256 	test.Printf(_L("Size=%u\n"),gFileEntry.iSize);
 
  1237 	
       
  1238 	if (gFileEntry.iSize!=0L)
 
  1257 	if (gFileEntry.iSize!=0L)
 
  1239 		Error(_L("Size check 0"),0);
 
  1258 		Error(_L("Size check 0"),0);
 
  1240 	
       
  1241 	saveTime=gFileEntry.iModified;
 
  1259 	saveTime=gFileEntry.iModified;
 
  1242 	test.Printf(_L("Wait 3 seconds...\n"));
 
  1260 	test.Printf(_L("Wait 3 seconds...\n"));
 
  1243 	User::After(3000000L);
 
  1261 	User::After(3000000L);
 
  1244 	gDataBuf.SetLength(1);
 
  1262 	gDataBuf.SetLength(1);
 
  1245 	
       
  1246 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1263 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1247 		Error(_L("Write 1"),c);
 
  1264 		Error(_L("Write 1"),c);
 
  1248 	
       
  1249          /* === pay attention to the code below if the "not updating file timestamp on Flush" mode is enabled (at least on FAT)
 
       
  1250          //-- the timestamp in the "real" entry on the media (RFs::Entry()) and what we get by RFile::Modified()
 
       
  1251          //-- can differ even after flushing file. The timestamp will be updated only on _closing_ the file.
 
       
  1252          //-- This behaviour can be an optimisation to reduce number of media writes due to updating file timestamps.
 
       
  1253          gFile.Close();
 
       
  1254          nRes = gFile.Open(TheFs, gNameOut, EFileWrite);
 
       
  1255          test_KErrNone(nRes);
 
       
  1256          //-- restore the expected position in the file
 
       
  1257          TInt pos1 = 0;
 
       
  1258          nRes = gFile.Seek(ESeekEnd, pos1);
 
       
  1259          test_KErrNone(nRes);
 
       
  1260          //------------------------------------ 
       
  1261          */
 
       
  1262 
       
  1263 
       
  1264 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1265 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1265 		Error(_L("File info 1"),c);
 
  1266 		Error(_L("File info 1"),c);
 
  1266 	
       
  1267 	test.Printf(_L("Size=%u\n"),gFileEntry.iSize);
 
  1267 	test.Printf(_L("Size=%u\n"),gFileEntry.iSize);
 
  1268 	if (gFileEntry.iSize!=1L)
 
  1268 	if (gFileEntry.iSize!=1L)
 
  1269 		Error(_L("Size check 1"),0);
 
  1269 		Error(_L("Size check 1"),0);
 
  1270 	
       
  1271 	if (gFileEntry.iModified==saveTime)
 
  1270 	if (gFileEntry.iModified==saveTime)
 
  1272 		Error(_L("Time update"),0);
 
  1271 		Error(_L("Time update"),0);
 
  1273 
       
  1274 
       
  1275 	gDataBuf.SetLength(16384);
 
  1272 	gDataBuf.SetLength(16384);
 
  1276 	if ((c=gFile.Write(gDataBuf,16384))!=KErrNone)
 
  1273 	if ((c=gFile.Write(gDataBuf,16384))!=KErrNone)
 
  1277 		Error(_L("Write 2"),c);
 
  1274 		Error(_L("Write 2"),c);
 
  1278 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1275 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1279 		Error(_L("File info 2"),c);
 
  1276 		Error(_L("File info 2"),c);
 
  1280 	test.Printf(_L("Size=%u\n"),gFileEntry.iSize);
 
  1277 	test.Printf(_L("Size=%u\n"),gFileEntry.iSize);
 
  1281 	if (gFileEntry.iSize!=16385L)
 
  1278 	if (gFileEntry.iSize!=16385L)
 
  1282 		Error(_L("Size check 2"),0);
 
  1279 		Error(_L("Size check 2"),0);
 
  1283 	pos=0L;
 
  1280 	pos=0L;
 
  1284 	if ((c=gFile.Seek((TSeek)ESeekStart,pos))!=KErrNone)
 
  1281 	if ((c=gFile.Seek((TSeek)P_FABS,pos))!=KErrNone)
 
  1285 		Error(_L("Seek 0"),c);
 
  1282 		Error(_L("Seek 0"),c);
 
  1286 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1283 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1287 		Error(_L("Write 3"),c);
 
  1284 		Error(_L("Write 3"),c);
 
  1288 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1285 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1289 		Error(_L("File info 3"),c);
 
  1286 		Error(_L("File info 3"),c);
 
  1290 	test.Printf(_L("Size=%u\n"),gFileEntry.iSize);
 
  1287 	test.Printf(_L("Size=%u\n"),gFileEntry.iSize);
 
  1291 	if (gFileEntry.iSize!=16385L)
 
  1288 	if (gFileEntry.iSize!=16385L)
 
  1292 		Error(_L("Size check 3"),0);
 
  1289 		Error(_L("Size check 3"),0);
 
  1293 	pos=0L;
 
  1290 	pos=0L;
 
  1294 	if ((c=gFile.Seek((TSeek)ESeekStart,pos))!=KErrNone)
 
  1291 	if ((c=gFile.Seek((TSeek)P_FABS,pos))!=KErrNone)
 
  1295 		Error(_L("Seek 1"),c);
 
  1292 		Error(_L("Seek 1"),c);
 
  1296 	if ((c=gFile.Write(gDataBuf,16384))!=KErrNone)
 
  1293 	if ((c=gFile.Write(gDataBuf,16384))!=KErrNone)
 
  1297 		Error(_L("Write 4"),c);
 
  1294 		Error(_L("Write 4"),c);
 
  1298 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1295 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1299 		Error(_L("Write 5"),c);
 
  1296 		Error(_L("Write 5"),c);
 
  1331 	gFile.Close();
 
  1328 	gFile.Close();
 
  1332 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1329 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1333 		Error(_L("File info 8"),c);
 
  1330 		Error(_L("File info 8"),c);
 
  1334 	if (gFileEntry.iSize!=0L)
 
  1331 	if (gFileEntry.iSize!=0L)
 
  1335 		Error(_L("Size check 7"),0);
 
  1332 		Error(_L("Size check 7"),0);
 
  1336 	mask=KEntryAttArchive;
 
  1333 	mask=P_FAMOD;
 
  1337 	attrib=0;
 
  1334 	attrib=0;
 
  1338 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=KErrNone)
 
  1335 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=KErrNone)
 
  1339 		Error(_L("Att 20"),c);
 
  1336 		Error(_L("Att 20"),c);
 
  1340 
  1337 
  1341 //
 
  1338 //
 
  1342 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|EFileWrite))!=KErrNone)
 
  1339 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|P_FUPDATE|P_FRANDOM))!=KErrNone)
 
  1343 		Error(_L("Open 21"),c);
 
  1340 		Error(_L("Open 21"),c);
 
  1344 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1341 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1345 		Error(_L("File info 9"),c);
 
  1342 		Error(_L("File info 9"),c);
 
  1346 	if (gFileEntry.iAtt & KEntryAttArchive)
 
  1343 	if (gFileEntry.iAtt & P_FAMOD)
 
  1347 		Error(_L("Status 21"),0);
 
  1344 		Error(_L("Status 21"),0);
 
  1348 	if ((c=gFile.Write(gDataBuf,0))!=KErrNone)
 
  1345 	if ((c=gFile.Write(gDataBuf,0))!=KErrNone)
 
  1349 		Error(_L("Write 21"),c);
 
  1346 		Error(_L("Write 21"),c);
 
  1350 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1347 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1351 		Error(_L("File info 9"),c);
 
  1348 		Error(_L("File info 9"),c);
 
  1352 	if ((gFileEntry.iAtt & KEntryAttArchive))       // write 0 should not modify //
 
  1349 	if ((gFileEntry.iAtt & P_FAMOD))       // write 0 should not modify //
 
  1353 		Error(_L("Status 22"),0);
 
  1350 		Error(_L("Status 22"),0);
 
  1354 	gFile.Close();
 
  1351 	gFile.Close();
 
  1355 	mask=KEntryAttArchive;
 
  1352 	mask=P_FAMOD;
 
  1356 	attrib=0;
 
  1353 	attrib=0;
 
  1357 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=KErrNone)
 
  1354 	if ((c=TheFs.SetAtt(gNameOut,attrib,mask))!=KErrNone)
 
  1358 		Error(_L("Att 20"),c);
 
  1355 		Error(_L("Att 20"),c);
 
  1359 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|EFileWrite))!=KErrNone)
 
  1356 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|P_FUPDATE|P_FRANDOM))!=KErrNone)
 
  1360 		Error(_L("Open 22"),c);
 
  1357 		Error(_L("Open 22"),c);
 
  1361 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1358 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1362 		Error(_L("File info 9"),c);
 
  1359 		Error(_L("File info 9"),c);
 
  1363 	if (gFileEntry.iAtt & KEntryAttArchive)
 
  1360 	if (gFileEntry.iAtt & P_FAMOD)
 
  1364 		Error(_L("Status 23"),0);
 
  1361 		Error(_L("Status 23"),0);
 
  1365 	pos=0L;
 
  1362 	pos=0L;
 
  1366 	if ((c=gFile.SetSize(pos))!=KErrNone)        // no change //
 
  1363 	if ((c=gFile.SetSize(pos))!=KErrNone)        // no change //
 
  1367 		Error(_L("Set EOF 21"),c);
 
  1364 		Error(_L("Set EOF 21"),c);
 
  1368 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1365 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1369 		Error(_L("File info 9"),c);
 
  1366 		Error(_L("File info 9"),c);
 
  1370 	if ((gFileEntry.iAtt & KEntryAttArchive))
 
  1367 	if ((gFileEntry.iAtt & P_FAMOD))
 
  1371 		Error(_L("Status 24"),0);
 
  1368 		Error(_L("Status 24"),0);
 
  1372 	gFile.Close();
 
  1369 	gFile.Close();
 
  1373 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1370 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1374 		Error(_L("File info 0"),c);
 
  1371 		Error(_L("File info 0"),c);
 
  1375 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|EFileWrite))!=KErrNone)
 
  1372 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|P_FUPDATE|P_FRANDOM))!=KErrNone)
 
  1376 		Error(_L("Open 23"),c);
 
  1373 		Error(_L("Open 23"),c);
 
  1377 	saveTime=gFileEntry.iModified;
 
  1374 	saveTime=gFileEntry.iModified;
 
  1378 	test.Printf(_L("Wait 3 seconds...\n"));
 
  1375 	test.Printf(_L("Wait 3 seconds...\n"));
 
  1379 	User::After(3000000L);
 
  1376 	User::After(3000000L);
 
  1380 	if ((c=gFile.Flush())!=KErrNone)        // Should not alter time //
 
  1377 	if ((c=gFile.Flush())!=KErrNone)        // Should not alter time //
 
  1384 	gFile.Close();
 
  1381 	gFile.Close();
 
  1385 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1382 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1386 		Error(_L("File info 61"),c);
 
  1383 		Error(_L("File info 61"),c);
 
  1387 	if (gFileEntry.iModified!=saveTime)
 
  1384 	if (gFileEntry.iModified!=saveTime)
 
  1388 		Error(_L("Close new time"),0);
 
  1385 		Error(_L("Close new time"),0);
 
  1389 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|EFileWrite))!=KErrNone)
 
  1386 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream|P_FUPDATE|P_FRANDOM))!=KErrNone)
 
  1390 		Error(_L("Open 24"),c);
 
  1387 		Error(_L("Open 24"),c);
 
  1391 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1388 	if ((c=gFile.Write(gDataBuf,1))!=KErrNone)
 
  1392 		Error(_L("Write 60"),c);
 
  1389 		Error(_L("Write 60"),c);
 
  1393 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1390 	if ((c=TheFs.Entry(gNameOut,gFileEntry))!=KErrNone)
 
  1394 		Error(_L("File info 62"),c);
 
  1391 		Error(_L("File info 62"),c);
 
  1413 		Error(_L("Open 10"),c);
 
  1410 		Error(_L("Open 10"),c);
 
  1414 	gFile.Close();
 
  1411 	gFile.Close();
 
  1415 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream))!=KErrNone)
 
  1412 	if ((c=gFile.Open(TheFs,gNameOut,EFileStream))!=KErrNone)
 
  1416 		Error(_L("Open 10"),c); // Temp file is created as writable. 
  1413 		Error(_L("Open 10"),c); // Temp file is created as writable. 
  1417 	TTime fileTime(0);
 
  1414 	TTime fileTime(0);
 
  1418 	if ((c=gFile.SetModified(fileTime))!=KErrAccessDenied) // KErrInUse)
 
  1415 	if ((c=gFile.SetModified(fileTime))!=AccessErr) // LockedErr)
 
  1419 		Error(_L("Set file date 10"),c);
 
  1416 		Error(_L("Set file date 10"),c);
 
  1420 	gFile.Close();
 
  1417 	gFile.Close();
 
  1421 
  1418 
  1422 
  1419 
  1423 	for (i=0;i<DateTests;i++)
 
  1420 	for (i=0;i<DateTests;i++)
 
  1449 		Error(_L("Delete 1"),c);
 
  1446 		Error(_L("Delete 1"),c);
 
  1450 	test.Printf(_L("Test format\n"));
 
  1447 	test.Printf(_L("Test format\n"));
 
  1451 	gNameOut.SetLength(0);
 
  1448 	gNameOut.SetLength(0);
 
  1452 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream))!=KErrNone)
 
  1449 	if ((c=gFile.Temp(TheFs,gNameBuf,gNameOut,EFileStream))!=KErrNone)
 
  1453 		Error(_L("Open 1"),c);
 
  1450 		Error(_L("Open 1"),c);
 
  1454 	if ((c=gFormat.Open(TheFs,fBuf,EFullFormat,count))!=KErrInUse)
 
  1451 	if ((c=gFormat.Open(TheFs,fBuf,EFullFormat,count))!=LockedErr)
 
  1455 		Error(_L("Format lock check 1"),c);
 
  1452 		Error(_L("Format lock check 1"),c);
 
  1456 	if ((c=gFormat.Open(TheFs,fBuf,EQuickFormat,count))!=KErrInUse)
 
  1453 	if ((c=gFormat.Open(TheFs,fBuf,EQuickFormat,count))!=LockedErr)
 
  1457 		Error(_L("Format lock check 2"),c);
 
  1454 		Error(_L("Format lock check 2"),c);
 
  1458 	gFile.Close();
 
  1455 	gFile.Close();
 
  1459 
  1456 
  1460 	if ((c=gFormat.Open(TheFs,fBuf,EFullFormat,count))!=KErrNone)
 
  1457 	if ((c=gFormat.Open(TheFs,fBuf,EFullFormat,count))!=KErrNone)
 
  1461 		{
 
  1458 		{
 
  1462 		if (c==KErrInUse || c==KErrAccessDenied)
 
  1459 		if (c==LockedErr || c==AccessErr)
 
  1463 			{
 
  1460 			{
 
  1464 			test.Printf(_L("Format: locked, no test\n"));
 
  1461 			test.Printf(_L("Format: locked, no test\n"));
 
  1465 			}
 
  1462 			}
 
  1466 		    else
 
  1463 		    else
 
  1467             {
 
  1464             {
FCL/sf/os/kernelhwsrv