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/t_dctcballfiles.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 <e32std.h>
 
    18 #include <e32std.h>
 
    20 #include <e32std_private.h>
 
    19 #include <e32std_private.h>
 
    21 #include <e32svr.h>
 
    20 #include <e32svr.h>
 
    75 TRequestStatus aStat1;
 
    74 TRequestStatus aStat1;
 
    76 TRequestStatus aStat2;
 
    75 TRequestStatus aStat2;
 
    77 TRequestStatus aStat3;
 
    76 TRequestStatus aStat3;
 
    78 TRequestStatus aStat4;
 
    77 TRequestStatus aStat4;
 
    79 
    78 
       
    79 TVolumeInfo aVolInfo;
 
       
    80 //	TDriveInfo adriveInfo;
 
       
    81 
    80 TBuf<40> systestfile;
 
    82 TBuf<40> systestfile;
 
    81 TBuf<40> pritestfile;
 
    83 TBuf<40> pritestfile;
 
    82 TBuf<40> restestfile;
 
    84 TBuf<40> restestfile;
 
    83 TBuf<40> systestfile1;
 
    85 TBuf<40> systestfile1;
 
    84 TBuf<40> pritestfile1;
 
    86 TBuf<40> pritestfile1;
 
   102 	
   104 	
   103 	mkdirname.Zero();
 
   105 	mkdirname.Zero();
 
   104 	mkdirname.Append(systestname);
 
   106 	mkdirname.Append(systestname);
 
   105 	mkdirname.Append(KMkDirSub);
 
   107 	mkdirname.Append(KMkDirSub);
 
   106 	r=TheFs.MkDirAll(mkdirname);	
   108 	r=TheFs.MkDirAll(mkdirname);	
   107 	test_KErrNone(r);
 
   109 	test(r==KErrNone);
 
   108 
   110 
   109 	TheFs.RmDir(mkdirname);
 
   111 	TheFs.RmDir(mkdirname);
 
   110 	test_KErrNone(r);
 
   112 	test(r==KErrNone);
 
   111 
   113 
   112 	r=TheFs.SetSubst(systestname,EDriveO);
 
   114 	r=TheFs.SetSubst(systestname,EDriveO);
 
   113 	test_Value(r, r == KErrPermissionDenied);
 
   115 	test(r==KErrPermissionDenied);
 
   114 	
   116 	
   115 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   117 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   116 	test_KErrNone(r);
 
   118 	test(r==KErrNone);
 
   117 
   119 
   118 	r=TheFs.SetSessionPath(systestname);
 
   120 	r=TheFs.SetSessionPath(systestname);
 
   119 	test_KErrNone(r);
 
   121 	test(r==KErrNone);
 
   120 	
   122 	
   121 	TheFs.NotifyChange(ENotifyAll,aStat1,systestname);
 
   123 	TheFs.NotifyChange(ENotifyAll,aStat1,systestname);
 
   122 	test(aStat1==KRequestPending);
 
   124 	test(aStat1==KRequestPending);
 
   123 
   125 
   124 	systestfile=KSystemPath;
 
   126 	systestfile=KSystemPath;
 
   129 	
   131 	
   130 	oldName=KOldFile;
 
   132 	oldName=KOldFile;
 
   131 	oldName[0]=(TText)gDriveToTest;
 
   133 	oldName[0]=(TText)gDriveToTest;
 
   132 
   134 
   133 	r=TheFs.GetShortName(systestfile, shortfilename);
 
   135 	r=TheFs.GetShortName(systestfile, shortfilename);
 
   134 	test_Value(r, r == KErrNotFound || r==KErrNotSupported);
 
   136 	test(r==KErrNotFound || r==KErrNotSupported);
 
   135 
   137 
   136 	r=TheFs.GetLongName(systestfile1, longfilename);
 
   138 	r=TheFs.GetLongName(systestfile1, longfilename);
 
   137 	test_Value(r, r == KErrNotFound || r==KErrNotSupported);
 
   139 	test(r==KErrNotFound || r==KErrNotSupported);
 
   138 
   140 
   139 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   141 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   140 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   142 	test(r==KErrNone || r==KErrAlreadyExists);
 
   141 	file1.Close();
 
   143 	file1.Close();
 
   142 
   144 
   143 	r=TheFs.Replace(oldName,systestfile);
 
   145 	r=TheFs.Replace(oldName,systestfile);
 
   144 	test_KErrNone(r);
 
   146 	test(r==KErrNone);
 
   145 	
   147 	
   146 	r=TheFs.Rename(systestfile,systestfile1);
 
   148 	r=TheFs.Rename(systestfile,systestfile1);
 
   147 	test_KErrNone(r);
 
   149 	test(r==KErrNone);
 
   148 	
   150 	
   149 	r=TheFs.Entry(systestfile1,entry);
 
   151 	r=TheFs.Entry(systestfile1,entry);
 
   150 	test_KErrNone(r);
 
   152 	test(r==KErrNone);
 
   151 
   153 
   152 	r=TheFs.SetEntry(systestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   154 	r=TheFs.SetEntry(systestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   153 	test_KErrNone(r);
 
   155 	test(r==KErrNone);
 
   154 
   156 
   155 	r=TheFs.Delete(systestfile1);
 
   157 	r=TheFs.Delete(systestfile1);
 
   156 	test_KErrNone(r);
 
   158 	test(r==KErrNone);
 
   157 	}
 
   159 	}
 
   158 
   160 
   159 LOCAL_C void ResourceRFsTest()
 
   161 LOCAL_C void ResourceRFsTest()
 
   160 //
 
   162 //
 
   161 //
 
   163 //
 
   166 	
   168 	
   167 	mkdirname.Zero();
 
   169 	mkdirname.Zero();
 
   168 	mkdirname.Append(restestname);
 
   170 	mkdirname.Append(restestname);
 
   169 	mkdirname.Append(KMkDirSub);
 
   171 	mkdirname.Append(KMkDirSub);
 
   170 	r=TheFs.MkDirAll(mkdirname);	
   172 	r=TheFs.MkDirAll(mkdirname);	
   171 	test_KErrNone(r);
 
   173 	test(r==KErrNone);
 
   172 
   174 
   173 	TheFs.RmDir(mkdirname);
 
   175 	TheFs.RmDir(mkdirname);
 
   174 	test_KErrNone(r);
 
   176 	test(r==KErrNone);
 
   175 
   177 
   176 	r=TheFs.SetSubst(restestname,EDriveO);
 
   178 	r=TheFs.SetSubst(restestname,EDriveO);
 
   177 	test_Value(r, r == KErrPermissionDenied);
 
   179 	test(r==KErrPermissionDenied);
 
   178 	
   180 	
   179 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   181 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   180 	test_KErrNone(r);
 
   182 	test(r==KErrNone);
 
   181 
   183 
   182 	r=TheFs.SetSessionPath(restestname);
 
   184 	r=TheFs.SetSessionPath(restestname);
 
   183 	test_KErrNone(r);
 
   185 	test(r==KErrNone);
 
   184 	
   186 	
   185 	TheFs.NotifyChange(ENotifyAll,aStat4,restestname);
 
   187 	TheFs.NotifyChange(ENotifyAll,aStat4,restestname);
 
   186 	test(aStat4==KRequestPending);
 
   188 	test(aStat4==KRequestPending);
 
   187 
   189 
   188 	restestfile=KResourcePath;
 
   190 	restestfile=KResourcePath;
 
   193 	
   195 	
   194 	oldName=KOldFile;
 
   196 	oldName=KOldFile;
 
   195 	oldName[0]=(TText)gDriveToTest;
 
   197 	oldName[0]=(TText)gDriveToTest;
 
   196 
   198 
   197 	r=TheFs.GetShortName(restestfile, shortfilename);
 
   199 	r=TheFs.GetShortName(restestfile, shortfilename);
 
   198 	test_Value(r, r == KErrNone || r == KErrNotFound || r==KErrNotSupported);
 
   200 	test(r==KErrNone || KErrNotFound || r==KErrNotSupported);
 
   199 
   201 
   200 	r=TheFs.GetLongName(restestfile1, longfilename);
 
   202 	r=TheFs.GetLongName(restestfile1, longfilename);
 
   201 	test_Value(r, r == KErrNone || r == KErrNotFound || r==KErrNotSupported);
 
   203 	test(r==KErrNone || KErrNotFound || r==KErrNotSupported);
 
   202 
   204 
   203 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   205 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   204 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   206 	test(r==KErrNone || r==KErrAlreadyExists);
 
   205 	file1.Close();
 
   207 	file1.Close();
 
   206 
   208 
   207 	r=TheFs.Replace(oldName,restestfile);
 
   209 	r=TheFs.Replace(oldName,restestfile);
 
   208 	test_KErrNone(r);
 
   210 	test(r==KErrNone);
 
   209 	
   211 	
   210 	r=TheFs.Rename(restestfile,restestfile1);
 
   212 	r=TheFs.Rename(restestfile,restestfile1);
 
   211 	test_KErrNone(r);
 
   213 	test(r==KErrNone);
 
   212 	
   214 	
   213 	r=TheFs.Entry(restestfile1,entry);
 
   215 	r=TheFs.Entry(restestfile1,entry);
 
   214 	test_KErrNone(r);
 
   216 	test(r==KErrNone);
 
   215 
   217 
   216 	r=TheFs.SetEntry(restestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   218 	r=TheFs.SetEntry(restestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   217 	test_KErrNone(r);
 
   219 	test(r==KErrNone);
 
   218 
   220 
   219 	r=TheFs.Delete(restestfile1);
 
   221 	r=TheFs.Delete(restestfile1);
 
   220 	test_KErrNone(r);
 
   222 	test(r==KErrNone);
 
   221 
   223 
   222 	}
 
   224 	}
 
   223 
   225 
   224 
   226 
   225 LOCAL_C void privatefalseIDRFsTest()
 
   227 LOCAL_C void privatefalseIDRFsTest()
 
   233 	mkdirname.Zero();
 
   235 	mkdirname.Zero();
 
   234 	mkdirname.Append(pritestfalseidname);
 
   236 	mkdirname.Append(pritestfalseidname);
 
   235 	mkdirname.Append(KMkDirSub);
 
   237 	mkdirname.Append(KMkDirSub);
 
   236 
   238 
   237 	r=TheFs.MkDirAll(mkdirname);	
   239 	r=TheFs.MkDirAll(mkdirname);	
   238 	test_KErrNone(r);
 
   240 	test(r==KErrNone);
 
   239 
   241 
   240 	r=TheFs.RmDir(mkdirname);	
   242 	r=TheFs.RmDir(mkdirname);	
   241 	test_KErrNone(r);
 
   243 	test(r==KErrNone);
 
   242 
   244 
   243 	r=TheFs.SetSubst(pritestfalseidname,EDriveO);
 
   245 	r=TheFs.SetSubst(pritestfalseidname,EDriveO);
 
   244 	test_Value(r, r == KErrPermissionDenied);
 
   246 	test(r==KErrPermissionDenied);
 
   245 
   247 
   246 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   248 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   247 	test_KErrNone(r);
 
   249 	test(r==KErrNone);
 
   248 
   250 
   249 	r=TheFs.SetSessionPath(pritestfalseidname);
 
   251 	r=TheFs.SetSessionPath(pritestfalseidname);
 
   250 	test_KErrNone(r);
 
   252 	test(r==KErrNone);
 
   251 
   253 
   252 	TheFs.NotifyChange(ENotifyAll,aStat2,pritestfalseidname);
 
   254 	TheFs.NotifyChange(ENotifyAll,aStat2,pritestfalseidname);
 
   253 	test(aStat2==KRequestPending);
 
   255 	test(aStat2==KRequestPending);
 
   254 
   256 
   255 
   257 
   261 	
   263 	
   262 	oldName=KOldFile;
 
   264 	oldName=KOldFile;
 
   263 	oldName[0]=(TText)gDriveToTest;
 
   265 	oldName[0]=(TText)gDriveToTest;
 
   264 
   266 
   265 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   267 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   266 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   268 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   267 
   269 
   268 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   270 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   269 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   271 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   270 
   272 
   271 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   273 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   272 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   274 	test(r==KErrNone || r==KErrAlreadyExists);
 
   273 	file1.Close();
 
   275 	file1.Close();
 
   274 
   276 
   275 	r=TheFs.Replace(oldName,pritestfile);
 
   277 	r=TheFs.Replace(oldName,pritestfile);
 
   276 	test_KErrNone(r);
 
   278 	test(r==KErrNone);
 
   277 	
   279 	
   278 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   280 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   279 	test_KErrNone(r);
 
   281 	test(r==KErrNone);
 
   280 	
   282 	
   281 	r=TheFs.Entry(pritestfile1,entry);
 
   283 	r=TheFs.Entry(pritestfile1,entry);
 
   282 	test_KErrNone(r);
 
   284 	test(r==KErrNone);
 
   283 
   285 
   284 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   286 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   285 	test_KErrNone(r);
 
   287 	test(r==KErrNone);
 
   286 
   288 
   287 	r=TheFs.Delete(pritestfile1);
 
   289 	r=TheFs.Delete(pritestfile1);
 
   288 	test_KErrNone(r);
 
   290 	test(r==KErrNone);
 
   289 
   291 
   290 	}
 
   292 	}
 
   291 
   293 
   292 
   294 
   293 LOCAL_C void privateRFsTest()
 
   295 LOCAL_C void privateRFsTest()
 
   302 	mkdirname.Zero();
 
   304 	mkdirname.Zero();
 
   303 	mkdirname.Append(pritestname);
 
   305 	mkdirname.Append(pritestname);
 
   304 	mkdirname.Append(KMkDirSub);
 
   306 	mkdirname.Append(KMkDirSub);
 
   305 
   307 
   306 	r=TheFs.MkDirAll(mkdirname);	
   308 	r=TheFs.MkDirAll(mkdirname);	
   307 	test_KErrNone(r);
 
   309 	test(r==KErrNone);
 
   308 
   310 
   309 	r=TheFs.RmDir(mkdirname);	
   311 	r=TheFs.RmDir(mkdirname);	
   310 	test_KErrNone(r);
 
   312 	test(r==KErrNone);
 
   311 
   313 
   312 	r=TheFs.SetSubst(pritestname,EDriveO);
 
   314 	r=TheFs.SetSubst(pritestname,EDriveO);
 
   313 	test_Value(r, r == KErrPermissionDenied);
 
   315 	test(r==KErrPermissionDenied);
 
   314 
   316 
   315 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   317 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   316 	test_KErrNone(r);
 
   318 	test(r==KErrNone);
 
   317 
   319 
   318 	r=TheFs.SetSessionPath(pritestname);
 
   320 	r=TheFs.SetSessionPath(pritestname);
 
   319 	test_KErrNone(r);
 
   321 	test(r==KErrNone);
 
   320 
   322 
   321 	TheFs.NotifyChange(ENotifyAll,aStat2,pritestname);
 
   323 	TheFs.NotifyChange(ENotifyAll,aStat2,pritestname);
 
   322 	test(aStat2==KRequestPending);
 
   324 	test(aStat2==KRequestPending);
 
   323 
   325 
   324 
   326 
   330 	
   332 	
   331 	oldName=KOldFile;
 
   333 	oldName=KOldFile;
 
   332 	oldName[0]=(TText)gDriveToTest;
 
   334 	oldName[0]=(TText)gDriveToTest;
 
   333 
   335 
   334 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   336 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   335 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   337 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   336 
   338 
   337 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   339 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   338 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   340 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   339 
   341 
   340 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   342 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   341 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   343 	test(r==KErrNone || r==KErrAlreadyExists);
 
   342 	file1.Close();
 
   344 	file1.Close();
 
   343 
   345 
   344 	r=TheFs.Replace(oldName,pritestfile);
 
   346 	r=TheFs.Replace(oldName,pritestfile);
 
   345 	test_KErrNone(r);
 
   347 	test(r==KErrNone);
 
   346 	
   348 	
   347 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   349 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   348 	test_KErrNone(r);
 
   350 	test(r==KErrNone);
 
   349 	
   351 	
   350 	r=TheFs.Entry(pritestfile1,entry);
 
   352 	r=TheFs.Entry(pritestfile1,entry);
 
   351 	test_KErrNone(r);
 
   353 	test(r==KErrNone);
 
   352 
   354 
   353 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   355 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   354 	test_KErrNone(r);
 
   356 	test(r==KErrNone);
 
   355 
   357 
   356 	r=TheFs.Delete(pritestfile1);
 
   358 	r=TheFs.Delete(pritestfile1);
 
   357 	test_KErrNone(r);
 
   359 	test(r==KErrNone);
 
   358 
   360 
   359 	}
 
   361 	}
 
   360 
   362 
   361 
   363 
   362 LOCAL_C void privateSIDRFstest()
 
   364 LOCAL_C void privateSIDRFstest()
 
   366 
   368 
   367 	mkdirname.Zero();
 
   369 	mkdirname.Zero();
 
   368 	mkdirname.Append(theprivatepath);
 
   370 	mkdirname.Append(theprivatepath);
 
   369 	mkdirname.Append(KMkDirSub);
 
   371 	mkdirname.Append(KMkDirSub);
 
   370 	r=TheFs.MkDirAll(mkdirname);	
   372 	r=TheFs.MkDirAll(mkdirname);	
   371 	test_KErrNone(r);
 
   373 	test(r==KErrNone);
 
   372 
   374 
   373 	r=TheFs.RmDir(mkdirname);	
   375 	r=TheFs.RmDir(mkdirname);	
   374 	test_KErrNone(r);
 
   376 	test(r==KErrNone);
 
   375 
   377 
   376 	r=TheFs.SetSubst(theprivatepath,EDriveO);	
   378 	r=TheFs.SetSubst(theprivatepath,EDriveO);	
   377 	test_Value(r, r == KErrPermissionDenied);
 
   379 	test(r==KErrPermissionDenied);
 
   378 
   380 
   379 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   381 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   380 	test_KErrNone(r);
 
   382 	test(r==KErrNone);
 
   381 
   383 
   382 	r=TheFs.SetSessionPath(theprivatepath);
 
   384 	r=TheFs.SetSessionPath(theprivatepath);
 
   383 	test_KErrNone(r);
 
   385 	test(r==KErrNone);
 
   384 
   386 
   385 	TheFs.NotifyChange(ENotifyAll,aStat3,theprivatepath);
 
   387 	TheFs.NotifyChange(ENotifyAll,aStat3,theprivatepath);
 
   386 	test(aStat3==KRequestPending);
 
   388 	test(aStat3==KRequestPending);
 
   387 
   389 
   388 	pritestfile=theprivatepath;
 
   390 	pritestfile=theprivatepath;
 
   393 	
   395 	
   394 	oldName=KOldFile;
 
   396 	oldName=KOldFile;
 
   395 	oldName[0]=(TText)gDriveToTest;
 
   397 	oldName[0]=(TText)gDriveToTest;
 
   396 
   398 
   397 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   399 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   398 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   400 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   399 
   401 
   400 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   402 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   401 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   403 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   402 
   404 
   403 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   405 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   404 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   406 	test(r==KErrNone || r==KErrAlreadyExists);
 
   405 	file1.Close();
 
   407 	file1.Close();
 
   406 
   408 
   407 	r=TheFs.Replace(oldName,pritestfile);
 
   409 	r=TheFs.Replace(oldName,pritestfile);
 
   408 	test_KErrNone(r);
 
   410 	test(r==KErrNone);
 
   409 	
   411 	
   410 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   412 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   411 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   413 	test(r==KErrNone || r==KErrAlreadyExists);
 
   412 	
   414 	
   413 	r=TheFs.Entry(pritestfile1,entry);
 
   415 	r=TheFs.Entry(pritestfile1,entry);
 
   414 	test_KErrNone(r);
 
   416 	test(r==KErrNone);
 
   415 
   417 
   416 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   418 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   417 	test_KErrNone(r);
 
   419 	test(r==KErrNone);
 
   418 
   420 
   419 	r=TheFs.Delete(pritestfile1);
 
   421 	r=TheFs.Delete(pritestfile1);
 
   420 	test_KErrNone(r);
 
   422 	test(r==KErrNone);
 
   421 	}
 
   423 	}
 
   422 
   424 
   423 
   425 
   424 LOCAL_C void systemRFiletest()
 
   426 LOCAL_C void systemRFiletest()
 
   425 //
 
   427 //
 
   426 //RFile testing with session path set to //system//
 
   428 //RFile testing with session path set to //system//
 
   427 //
 
   429 //
 
   428 	{
 
   430 	{
 
   429 
   431 
   430 	r=TheFs.SetSessionPath(systestname);
 
   432 	r=TheFs.SetSessionPath(systestname);
 
   431 	test_KErrNone(r);
 
   433 	test(r==KErrNone);
 
   432 
   434 
   433 	r=file1.Temp(TheFs,systestname,fromTemp,EFileWrite);
 
   435 	r=file1.Temp(TheFs,systestname,fromTemp,EFileWrite);
 
   434 	test_KErrNone(r);
 
   436 	test(r==KErrNone);
 
   435 	file1.Close();
 
   437 	file1.Close();
 
   436 
   438 
   437 	r=file1.Create(TheFs,KFileSys,EFileWrite);
 
   439 	r=file1.Create(TheFs,KFileSys,EFileWrite);
 
   438 	test_KErrNone(r);
 
   440 	test(r==KErrNone);
 
   439 	file1.Close();
 
   441 	file1.Close();
 
   440 
   442 
   441 	r=file1.Open(TheFs,KFileSys,EFileWrite);
 
   443 	r=file1.Open(TheFs,KFileSys,EFileWrite);
 
   442 	test_KErrNone(r);
 
   444 	test(r==KErrNone);
 
   443 	file1.Close();
 
   445 	file1.Close();
 
   444 	
   446 	
   445 	r=file1.Open(TheFs,KFileSys,EFileRead);
 
   447 	r=file1.Open(TheFs,KFileSys,EFileRead);
 
   446 	test_KErrNone(r);
 
   448 	test(r==KErrNone);
 
   447 	file1.Close();
 
   449 	file1.Close();
 
   448 
   450 
   449 	r=file1.Replace(TheFs,KFileSys,EFileWrite);
 
   451 	r=file1.Replace(TheFs,KFileSys,EFileWrite);
 
   450 	test_KErrNone(r);
 
   452 	test(r==KErrNone);
 
   451 	
   453 	
   452 	r=file1.Rename(KFileSys3);
 
   454 	r=file1.Rename(KFileSys3);
 
   453 	test_KErrNone(r);
 
   455 	test(r==KErrNone);
 
   454 	file1.Close();
 
   456 	file1.Close();
 
   455 
   457 
   456     TFindFile finder(TheFs);
 
   458     TFindFile finder(TheFs);
 
   457     CDir* dir = NULL;
 
   459     CDir* dir = NULL;
 
   458     r=finder.FindWildByDir(KWildFile, KWildPath, dir);
 
   460     r=finder.FindWildByDir(KWildFile, KWildPath, dir);
 
   459 	if (!(r==KErrNone))
 
   461 	if (!(r==KErrNone))
 
   460         test.Printf(_L("T_DCTCBALLFILES: test find wildcards r = %d (expected KErrNone)\n"), r);
 
   462         test.Printf(_L("T_DCTCBALLFILES: test find wildcards r = %d (expected KErrNone)\n"), r);
 
   461 	test_KErrNone(r);
 
   463 	test(r==KErrNone);
 
   462 	delete dir;
 
   464 	delete dir;
 
   463 	}
 
   465 	}
 
   464 
   466 
   465 LOCAL_C void resourceRFiletest()
 
   467 LOCAL_C void resourceRFiletest()
 
   466 //
 
   468 //
 
   467 //RFile testing with session path set to //resource//
 
   469 //RFile testing with session path set to //resource//
 
   468 //
 
   470 //
 
   469 	{
 
   471 	{
 
   470 	r=TheFs.SetSessionPath(restestname);
 
   472 	r=TheFs.SetSessionPath(restestname);
 
   471 	test_KErrNone(r);
 
   473 	test(r==KErrNone);
 
   472 
   474 
   473 	r=file1.Temp(TheFs,restestname,fromTemp,EFileWrite);
 
   475 	r=file1.Temp(TheFs,restestname,fromTemp,EFileWrite);
 
   474 	test_KErrNone(r);
 
   476 	test(r==KErrNone);
 
   475 	file1.Close();
 
   477 	file1.Close();
 
   476 
   478 
   477 	r=file1.Create(TheFs,KFileRes,EFileWrite);
 
   479 	r=file1.Create(TheFs,KFileRes,EFileWrite);
 
   478 	test_KErrNone(r);
 
   480 	test(r==KErrNone);
 
   479 	file1.Close();
 
   481 	file1.Close();
 
   480 
   482 
   481 	r=file1.Open(TheFs,KFileRes,EFileWrite|EFileShareExclusive );
 
   483 	r=file1.Open(TheFs,KFileRes,EFileWrite|EFileShareExclusive );
 
   482 	test_KErrNone(r);
 
   484 	test(r==KErrNone);
 
   483 	
   485 	
   484 	r=file1.Rename(KFileRes3);
 
   486 	r=file1.Rename(KFileRes3);
 
   485 	test_KErrNone(r);
 
   487 	test(r==KErrNone);
 
   486 	file1.Close();
 
   488 	file1.Close();
 
   487 
   489 
   488 	r=file1.Open(TheFs,KFileRes3,EFileShareReadersOrWriters|EFileRead);
 
   490 	r=file1.Open(TheFs,KFileRes3,EFileShareReadersOrWriters|EFileRead);
 
   489 	test_KErrNone(r);
 
   491 	test(r==KErrNone);
 
   490 	file1.Close();
 
   492 	file1.Close();
 
   491 
   493 
   492 	r=file1.Open(TheFs,KFileRes3,EFileShareReadersOrWriters|EFileWrite);
 
   494 	r=file1.Open(TheFs,KFileRes3,EFileShareReadersOrWriters|EFileWrite);
 
   493 	test_KErrNone(r);
 
   495 	test(r==KErrNone);
 
   494 	file1.Close();
 
   496 	file1.Close();
 
   495 
   497 
   496 	r=file1.Open(TheFs,KFileRes3,EFileShareReadersOnly);
 
   498 	r=file1.Open(TheFs,KFileRes3,EFileShareReadersOnly);
 
   497 	test_KErrNone(r);
 
   499 	test(r==KErrNone);
 
   498 
   500 
   499 	r=file1.ChangeMode(EFileShareExclusive);
 
   501 	r=file1.ChangeMode(EFileShareExclusive);
 
   500 	test_KErrNone(r);
 
   502 	test(r==KErrNone);
 
   501 	file1.Close();
 
   503 	file1.Close();
 
   502 
   504 
   503 	r=file1.Replace(TheFs,KFileRes,EFileWrite);
 
   505 	r=file1.Replace(TheFs,KFileRes,EFileWrite);
 
   504 	test_KErrNone(r);
 
   506 	test(r==KErrNone);
 
   505 	file1.Close();	
   507 	file1.Close();	
   506 	}
 
   508 	}
 
   507 
   509 
   508 
   510 
   509 LOCAL_C void privateRFiletest()
 
   511 LOCAL_C void privateRFiletest()
 
   510 //
 
   512 //
 
   511 //RFile testing with session path set to //Private//
 
   513 //RFile testing with session path set to //Private//
 
   512 //
 
   514 //
 
   513 	{
 
   515 	{
 
   514 	r=TheFs.SetSessionPath(pritestfalseidname);
 
   516 	r=TheFs.SetSessionPath(pritestfalseidname);
 
   515 	test_KErrNone(r);
 
   517 	test(r==KErrNone);
 
   516 
   518 
   517 	r=file1.Temp(TheFs,pritestfalseidname,fromTemp,EFileWrite);
 
   519 	r=file1.Temp(TheFs,pritestfalseidname,fromTemp,EFileWrite);
 
   518 	test_KErrNone(r);
 
   520 	test(r==KErrNone);
 
   519 	file1.Close();
 
   521 	file1.Close();
 
   520 
   522 
   521 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   523 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   522 	test_KErrNone(r);
 
   524 	test(r==KErrNone);
 
   523 	file1.Close();
 
   525 	file1.Close();
 
   524 
   526 
   525 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   527 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   526 	test_KErrNone(r);
 
   528 	test(r==KErrNone);
 
   527 	file1.Close();
 
   529 	file1.Close();
 
   528 	
   530 	
   529 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   531 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   530 	test_KErrNone(r);
 
   532 	test(r==KErrNone);
 
   531 	file1.Close();
 
   533 	file1.Close();
 
   532 	
   534 	
   533 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   535 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   534 	test_KErrNone(r);
 
   536 	test(r==KErrNone);
 
   535 	
   537 	
   536 	r=file1.Rename(KFilePri3);
 
   538 	r=file1.Rename(KFilePri3);
 
   537 	test_KErrNone(r);
 
   539 	test(r==KErrNone);
 
   538 	file1.Close();
 
   540 	file1.Close();
 
   539 	}
 
   541 	}
 
   540 
   542 
   541 
   543 
   542 LOCAL_C void privatefalseIDRFiletest()
 
   544 LOCAL_C void privatefalseIDRFiletest()
 
   543 //
 
   545 //
 
   544 //RFile testing with session path set to //Private//
 
   546 //RFile testing with session path set to //Private//
 
   545 //
 
   547 //
 
   546 	{
 
   548 	{
 
   547 	r=TheFs.SetSessionPath(pritestname);
 
   549 	r=TheFs.SetSessionPath(pritestname);
 
   548 	test_KErrNone(r);
 
   550 	test(r==KErrNone);
 
   549 
   551 
   550 	r=file1.Temp(TheFs,pritestname,fromTemp,EFileWrite);
 
   552 	r=file1.Temp(TheFs,pritestname,fromTemp,EFileWrite);
 
   551 	test_KErrNone(r);
 
   553 	test(r==KErrNone);
 
   552 	file1.Close();
 
   554 	file1.Close();
 
   553 
   555 
   554 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   556 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   555 	test_KErrNone(r);
 
   557 	test(r==KErrNone);
 
   556 	file1.Close();
 
   558 	file1.Close();
 
   557 
   559 
   558 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   560 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   559 	test_KErrNone(r);
 
   561 	test(r==KErrNone);
 
   560 	file1.Close();
 
   562 	file1.Close();
 
   561 	
   563 	
   562 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   564 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   563 	test_KErrNone(r);
 
   565 	test(r==KErrNone);
 
   564 	file1.Close();
 
   566 	file1.Close();
 
   565 	
   567 	
   566 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   568 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   567 	test_KErrNone(r);
 
   569 	test(r==KErrNone);
 
   568 	
   570 	
   569 	r=file1.Rename(KFilePri3);
 
   571 	r=file1.Rename(KFilePri3);
 
   570 	test_KErrNone(r);
 
   572 	test(r==KErrNone);
 
   571 	file1.Close();
 
   573 	file1.Close();
 
   572 	}
 
   574 	}
 
   573 
   575 
   574 
   576 
   575 LOCAL_C void privateSIDRFiletest()
 
   577 LOCAL_C void privateSIDRFiletest()
 
   576 //
 
   578 //
 
   577 //Rfile Testing with session path set to //Private//UID//
 
   579 //Rfile Testing with session path set to //Private//UID//
 
   578 //
 
   580 //
 
   579 	{
 
   581 	{
 
   580 	r=TheFs.SetSessionToPrivate(gTheDriveNum);
 
   582 	r=TheFs.SetSessionToPrivate(gTheDriveNum);
 
   581 	test_KErrNone(r);
 
   583 	test(r==KErrNone);
 
   582 	
   584 	
   583 	r=file1.Temp(TheFs,theprivatepath,fromTemp,EFileWrite);
 
   585 	r=file1.Temp(TheFs,theprivatepath,fromTemp,EFileWrite);
 
   584 	test_KErrNone(r);
 
   586 	test(r==KErrNone);
 
   585 	file1.Close();
 
   587 	file1.Close();
 
   586 
   588 
   587 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   589 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   588 	test_KErrNone(r);
 
   590 	test(r==KErrNone);
 
   589 	file1.Close();
 
   591 	file1.Close();
 
   590 
   592 
   591 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   593 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   592 	test_KErrNone(r);
 
   594 	test(r==KErrNone);
 
   593 	file1.Close();
 
   595 	file1.Close();
 
   594 	
   596 	
   595 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   597 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   596 	test_KErrNone(r);
 
   598 	test(r==KErrNone);
 
   597 	file1.Close();
 
   599 	file1.Close();
 
   598 	
   600 	
   599 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   601 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   600 	test_KErrNone(r);
 
   602 	test(r==KErrNone);
 
   601 	
   603 	
   602 	r=file1.Rename(KFilePri3);
 
   604 	r=file1.Rename(KFilePri3);
 
   603 	test_KErrNone(r);
 
   605 	test(r==KErrNone);
 
   604 	file1.Close();
 
   606 	file1.Close();
 
   605 	}
 
   607 	}
 
   606 
   608 
   607 LOCAL_C void RDirtest()
 
   609 LOCAL_C void RDirtest()
 
   608 //
 
   610 //
 
   613 	//system
 
   615 	//system
 
   614 	CDir*	dirEntries;
 
   616 	CDir*	dirEntries;
 
   615 	TBuf<30> dirNameBuf(KSystemPath);
 
   617 	TBuf<30> dirNameBuf(KSystemPath);
 
   616 	dirNameBuf[0]=(TText)gDriveToTest;
 
   618 	dirNameBuf[0]=(TText)gDriveToTest;
 
   617 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   619 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   618 	test_KErrNone(r);
 
   620 	test(r==KErrNone);
 
   619 	dir.Close();
 
   621 	dir.Close();
 
   620 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   622 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   621 	test_KErrNone(r);
 
   623 	test(r==KErrNone);
 
   622 	dirNameBuf.Zero();
 
   624 	dirNameBuf.Zero();
 
   623 	delete dirEntries;
 
   625 	delete dirEntries;
 
   624 
   626 
   625 	//Private
 
   627 	//Private
 
   626 	dirNameBuf=KPrivatePath;
 
   628 	dirNameBuf=KPrivatePath;
 
   627 	dirNameBuf[0]=(TText)gDriveToTest;
 
   629 	dirNameBuf[0]=(TText)gDriveToTest;
 
   628 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   630 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   629 	test_KErrNone(r);
 
   631 	test(r==KErrNone);
 
   630 	dir.Close();
 
   632 	dir.Close();
 
   631 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   633 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   632 	test_KErrNone(r);
 
   634 	test(r==KErrNone);
 
   633 	dirNameBuf.Zero();
 
   635 	dirNameBuf.Zero();
 
   634 	delete dirEntries;
 
   636 	delete dirEntries;
 
   635 
   637 
   636 	//Private//false ID
 
   638 	//Private//false ID
 
   637 	dirNameBuf=KPrivateFalseID;
 
   639 	dirNameBuf=KPrivateFalseID;
 
   638 	dirNameBuf[0]=(TText)gDriveToTest;
 
   640 	dirNameBuf[0]=(TText)gDriveToTest;
 
   639 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   641 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   640 	test_KErrNone(r);
 
   642 	test(r==KErrNone);
 
   641 	dir.Close();
 
   643 	dir.Close();
 
   642 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   644 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   643 	test_KErrNone(r);
 
   645 	test(r==KErrNone);
 
   644 	dirNameBuf.Zero();
 
   646 	dirNameBuf.Zero();
 
   645 	delete dirEntries;
 
   647 	delete dirEntries;
 
   646 
   648 
   647 	//Private/uid
 
   649 	//Private/uid
 
   648 	TheFs.PrivatePath(dirNameBuf);
 
   650 	TheFs.PrivatePath(dirNameBuf);
 
   649 	dirNameBuf.Insert(0,_L("?:"));
 
   651 	dirNameBuf.Insert(0,_L("?:"));
 
   650 	dirNameBuf[0]=(TText)gDriveToTest;
 
   652 	dirNameBuf[0]=(TText)gDriveToTest;
 
   651 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   653 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   652 	test_KErrNone(r);
 
   654 	test(r==KErrNone);
 
   653 	dir.Close();
 
   655 	dir.Close();
 
   654 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   656 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   655 	test_KErrNone(r);
 
   657 	test(r==KErrNone);
 
   656 	dirNameBuf.Zero();
 
   658 	dirNameBuf.Zero();
 
   657 	delete dirEntries;
 
   659 	delete dirEntries;
 
   658 	//Resource
 
   660 	//Resource
 
   659 	dirNameBuf=KResourcePath;
 
   661 	dirNameBuf=KResourcePath;
 
   660 	dirNameBuf[0]=(TText)gDriveToTest;
 
   662 	dirNameBuf[0]=(TText)gDriveToTest;
 
   661 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   663 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   662 	test_KErrNone(r);
 
   664 	test(r==KErrNone);
 
   663 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   665 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   664 	test_KErrNone(r);
 
   666 	test(r==KErrNone);
 
   665 	dir.Close();
 
   667 	dir.Close();
 
   666 	delete dirEntries;
 
   668 	delete dirEntries;
 
   667 	}
 
   669 	}
 
   668 
   670 
   669 
   671 
   671 //
 
   673 //
 
   672 //	Test with tcb capabilities
 
   674 //	Test with tcb capabilities
 
   673 //
 
   675 //
 
   674 	{
 
   676 	{
 
   675 	r=TheFs.FileSystemName(fsname,gTheDriveNum);
 
   677 	r=TheFs.FileSystemName(fsname,gTheDriveNum);
 
   676 	test_KErrNone(r);
 
   678 	test(r==KErrNone);
 
   677 	r = DismountFileSystem(TheFs, fsname, gTheDriveNum);
 
   679 	r = DismountFileSystem(TheFs, fsname, gTheDriveNum);
 
   678 	test_Value(r, r == KErrPermissionDenied);
 
   680 	test(r==KErrPermissionDenied);
 
   679 //	r=TheFs.RemoveFileSystem(fsname);	//can not test due to bug else where fix exists
 
   681 //	r=TheFs.RemoveFileSystem(fsname);	//can not test due to bug else where fix exists
 
   680 //	test_KErrNone(r);
 
   682 //	test(r==KErrNone);
 
   681 //	r=TheFs.AddFileSystem(fsname);
 
   683 //	r=TheFs.AddFileSystem(fsname);
 
   682 //	test_KErrNone(r);
 
   684 //	test(r==KErrNone);
 
   683 	r = MountFileSystem(TheFs, fsname, gTheDriveNum);
 
   685 	r = MountFileSystem(TheFs, fsname, gTheDriveNum);
 
   684 	test_Value(r, r == KErrPermissionDenied);
 
   686 	test(r==KErrPermissionDenied);
 
   685 	test.Printf(_L("r=%d"),r);
 
   687 	test.Printf(_L("r=%d"),r);
 
   686 	r=TheFs.SetDriveName(gTheDriveNum,KDriveName);
 
   688 	r=TheFs.SetDriveName(gTheDriveNum,KDriveName);
 
   687 	test_Value(r, r == KErrPermissionDenied);
 
   689 	test(r==KErrPermissionDenied);
 
   688 #ifndef __WINS__
 
   690 #ifndef __WINS__
 
   689  	r=TheFs.SetVolumeLabel(KVolLable, gTheDriveNum);
 
   691  	r=TheFs.SetVolumeLabel(KVolLable, gTheDriveNum);
 
   690 	test_Value(r, r == KErrPermissionDenied);
 
   692 	test(r==KErrPermissionDenied);
 
   691 #endif
 
   693 #endif
 
   692 
   694 
   693 	systemRFsTest();
 
   695 	systemRFsTest();
 
   694 	ResourceRFsTest();
 
   696 	ResourceRFsTest();
 
   695 	privateRFsTest();	
   697 	privateRFsTest();	
   711 	test(aStat2==KErrNone);
 
   713 	test(aStat2==KErrNone);
 
   712 	test(aStat3==KErrNone);
 
   714 	test(aStat3==KErrNone);
 
   713 	test(aStat4==KErrNone);
 
   715 	test(aStat4==KErrNone);
 
   714 
   716 
   715 	r=TheFs.SetSessionPath(systestname);
 
   717 	r=TheFs.SetSessionPath(systestname);
 
   716 	test_KErrNone(r);
 
   718 	test(r==KErrNone);
 
   717 	
   719 	
   718 //Test RRawDisk class
 
   720 //Test RRawDisk class
 
   719 	r=rawdisk.Open(TheFs,gTheDriveNum);
 
   721 	r=rawdisk.Open(TheFs,gTheDriveNum);
 
   720 	test_KErrNone(r);
 
   722 	test(r==KErrNone);
 
   721 	rawdisk.Close();
 
   723 	rawdisk.Close();
 
   722 
   724 
   723 	RDirtest();
 
   725 	RDirtest();
 
   724 
   726 
   725 #ifdef __WINS__
 
   727 #ifdef __WINS__
 
   726 	if (User::UpperCase(driveBuf[0]) != 'C')
 
   728 	if (User::UpperCase(driveBuf[0]) != 'C')
 
   727 #endif
 
   729 #endif
 
   728 		{
 
   730 		{
 
   729 		//Test RFormat class
 
   731 		//Test RFormat class
 
   730 		r=format.Open(TheFs,driveBuf,EHighDensity,count);
 
   732 		r=format.Open(TheFs,driveBuf,EHighDensity,count);
 
   731 		test_Value(r, r == KErrPermissionDenied);
 
   733 		test(r==KErrPermissionDenied);
 
   732 
   734 
   733 		while(count)	
   735 		while(count)	
   734 			{
 
   736 			{
 
   735 			TInt r=format.Next(count);
 
   737 			TInt r=format.Next(count);
 
   736 			test_KErrNone(r);
 
   738 			test(r==KErrNone);
 
   737 			}
 
   739 			}
 
   738 		format.Close();
 
   740 		format.Close();
 
   739 		}
 
   741 		}
 
   740 
   742 
   741 	driveBuf[0]=(TText)gDriveToTest;
 
   743 	driveBuf[0]=(TText)gDriveToTest;
 
   742 	r=TheFs.ScanDrive(driveBuf);
 
   744 	r=TheFs.ScanDrive(driveBuf);
 
   743 	RDebug::Print(_L("r=%d"),r);
 
   745 	RDebug::Print(_L("r=%d"),r);
 
   744 	test_Value(r, r == KErrPermissionDenied);
 
   746 	test(r==KErrPermissionDenied);
 
   745 	r=TheFs.CheckDisk(driveBuf);
 
   747 	r=TheFs.CheckDisk(driveBuf);
 
   746 	test_Value(r, r == KErrPermissionDenied);
 
   748 	test(r==KErrPermissionDenied);
 
   747 	}
 
   749 	}
 
   748 
   750 
   749 LOCAL_C void TestCaps()
 
   751 LOCAL_C void TestCaps()
 
   750 //
 
   752 //
 
   751 //	test format etc that require certain capabilities
 
   753 //	test format etc that require certain capabilities
 
   759 	r=RProcess().HasCapability(ECapabilityAllFiles, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg));
 
   761 	r=RProcess().HasCapability(ECapabilityAllFiles, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg));
 
   760 	test(r);
 
   762 	test(r);
 
   761 	
   763 	
   762 	driveBuf[0]=(TText)gDriveToTest;
 
   764 	driveBuf[0]=(TText)gDriveToTest;
 
   763 	r=TheFs.SessionPath(temp);
 
   765 	r=TheFs.SessionPath(temp);
 
   764 	test_KErrNone(r);
 
   766 	test(r==KErrNone);
 
   765 
   767 
   766 	test.Printf(_L("Session path: %S"),&temp);
 
   768 	test.Printf(_L("Session path: %S"),&temp);
 
   767 
   769 
   768 	r=TheFs.CreatePrivatePath(gTheDriveNum);
 
   770 	r=TheFs.CreatePrivatePath(gTheDriveNum);
 
   769 	test_Value(r, r == KErrNone || r== KErrAlreadyExists);
 
   771 	test(r==KErrNone || r== KErrAlreadyExists);
 
   770 
   772 
   771 	TBuf<18> tempPri;
 
   773 	TBuf<18> tempPri;
 
   772 	r=TheFs.PrivatePath(tempPri);
 
   774 	r=TheFs.PrivatePath(tempPri);
 
   773 	test_KErrNone(r);
 
   775 	test(r==KErrNone);
 
   774 	theprivatepath = _L("?:");
 
   776 	theprivatepath = _L("?:");
 
   775 	theprivatepath.Append(tempPri);
 
   777 	theprivatepath.Append(tempPri);
 
   776 
   778 
   777 	TestTcbAllfiles();
 
   779 	TestTcbAllfiles();
 
   778 	
   780 	
   779 	TFileName thesessionpath;
 
   781 	TFileName thesessionpath;
 
   780 	r=TheFs.SetSessionToPrivate(gTheDriveNum);
 
   782 	r=TheFs.SetSessionToPrivate(gTheDriveNum);
 
   781 	test_KErrNone(r);
 
   783 	test(r==KErrNone);
 
   782 	r=TheFs.SessionPath(thesessionpath);
 
   784 	r=TheFs.SessionPath(thesessionpath);
 
   783 	test_KErrNone(r);
 
   785 	test(r==KErrNone);
 
   784 
   786 
   785 	test(thesessionpath == theprivatepath);
 
   787 	test(thesessionpath == theprivatepath);
 
   786 	}
 
   788 	}
 
   787 
   789 
   788 
   790 
   790 
   792 
   791 LOCAL_C void ScanDir(const TDesC& aName, CDirScan::TScanDirection aDirection, TInt aError)
 
   793 LOCAL_C void ScanDir(const TDesC& aName, CDirScan::TScanDirection aDirection, TInt aError)
 
   792 	{
 
   794 	{
 
   793 	CDirScan* scanner = NULL;
 
   795 	CDirScan* scanner = NULL;
 
   794 	TRAP(r, scanner = CDirScan::NewL(TheFs));
 
   796 	TRAP(r, scanner = CDirScan::NewL(TheFs));
 
   795 	test_Value(r, r == KErrNone && scanner);
 
   797 	test(r == KErrNone && scanner);
 
   796 
   798 
   797 	TRAP(r, scanner->SetScanDataL(aName,KEntryAttDir,ESortByName|EAscending,aDirection));
 
   799 	TRAP(r, scanner->SetScanDataL(aName,KEntryAttDir,ESortByName|EAscending,aDirection));
 
   798 	test_KErrNone(r);
 
   800 	test(r == KErrNone);
 
   799 
   801 
   800 	CDir *entryList=NULL;
 
   802 	CDir *entryList=NULL;
 
   801 	for (;;)
 
   803 	for (;;)
 
   802 		{
 
   804 		{
 
   803 		TRAP(r, scanner->NextL(entryList));
 
   805 		TRAP(r, scanner->NextL(entryList));
 
   804 		test_Value(r, r == aError);
 
   806 		test(r == aError);
 
   805 		if (entryList==NULL)
 
   807 		if (entryList==NULL)
 
   806 			break;
 
   808 			break;
 
   807 
   809 
   808         TInt count=entryList->Count();
 
   810         TInt count=entryList->Count();
 
   809 
   811 
   841 		TBuf<30> privatepath;
 
   843 		TBuf<30> privatepath;
 
   842 		r=TheFs.PrivatePath(privatepath);
 
   844 		r=TheFs.PrivatePath(privatepath);
 
   843 		test.Printf(_L("Private Path is=%S"),&privatepath);
 
   845 		test.Printf(_L("Private Path is=%S"),&privatepath);
 
   844 		
   846 		
   845 		r = TheFs.MkDir(_L("\\Caged\\"));
 
   847 		r = TheFs.MkDir(_L("\\Caged\\"));
 
   846 		test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   848 		test(r==KErrNone || r==KErrAlreadyExists);
 
   847 		
   849 		
   848 		CDir* entryCount=NULL;
 
   850 		CDir* entryCount=NULL;
 
   849 		r=TheFs.GetDir(_L("\\*.*"),KEntryAttNormal|KEntryAttDir,ESortNone,entryCount);
 
   851 		r=TheFs.GetDir(_L("\\*.*"),KEntryAttNormal|KEntryAttDir,ESortNone,entryCount);
 
   850 		test_KErrNone(r);
 
   852 		test(r==KErrNone);
 
   851 		
   853 		
   852 		delete entryCount;
 
   854 		delete entryCount;
 
   853 		entryCount=NULL;
 
   855 		entryCount=NULL;
 
   854 
   856 
   855 
   857 
   856 		//Testing Copy
 
   858 		//Testing Copy
 
   857 		CDir* entryCount2=NULL;
 
   859 		CDir* entryCount2=NULL;
 
   858 		r=fMan->Copy(_L("\\sys\\"),_L("\\Caged\\"));
 
   860 		r=fMan->Copy(_L("\\sys\\"),_L("\\Caged\\"));
 
   859 		test_KErrNone(r);
 
   861 		test(r == KErrNone);
 
   860 		r=fMan->Copy(_L("\\*"),_L("\\Caged\\"));
 
   862 		r=fMan->Copy(_L("\\*"),_L("\\Caged\\"));
 
   861 		test_KErrNone(r);
 
   863 		test(r == KErrNone);
 
   862 		
   864 		
   863 		r=TheFs.GetDir(_L("\\Caged\\*.*"),KEntryAttNormal|KEntryAttDir,ESortNone,entryCount2);
 
   865 		r=TheFs.GetDir(_L("\\Caged\\*.*"),KEntryAttNormal|KEntryAttDir,ESortNone,entryCount2);
 
   864 		test_KErrNone(r);
 
   866 		test(r==KErrNone);
 
   865 		
   867 		
   866 		delete entryCount2;
 
   868 		delete entryCount2;
 
   867 		entryCount2=NULL;
 
   869 		entryCount2=NULL;
 
   868 	
   870 	
   869 		r=fMan->Copy(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); 
   871 		r=fMan->Copy(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); 
   870 		test_Value(r, r == KErrPathNotFound);
 
   872 		test(r == KErrPathNotFound);
 
   871 	
   873 	
   872 		// Create a test file
 
   874 		// Create a test file
 
   873 		RFile testFile;
 
   875 		RFile testFile;
 
   874 		r = testFile.Replace(TheFs, _L("\\capTest"),EFileWrite);
 
   876 		r = testFile.Replace(TheFs, _L("\\capTest"),EFileWrite);
 
   875 		test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   877 		test(r==KErrNone || r==KErrAlreadyExists);
 
   876 		testFile.Close();
 
   878 		testFile.Close();
 
   877 		
   879 		
   878 		TFileName name;
 
   880 		TFileName name;
 
   879 		name = privatepath;
 
   881 		name = privatepath;
 
   880 		name.Append(_L("privateFile.tst"));
 
   882 		name.Append(_L("privateFile.tst"));
 
   881 		RFile privateFile;
 
   883 		RFile privateFile;
 
   882 		r = privateFile.Replace(TheFs, name,EFileWrite);
 
   884 		r = privateFile.Replace(TheFs, name,EFileWrite);
 
   883 		test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   885 		test(r==KErrNone || r==KErrAlreadyExists);
 
   884 		privateFile.Close();
 
   886 		privateFile.Close();
 
   885 
   887 
   886 	
   888 	
   887 		r=fMan->Copy(_L("\\capTest"),_L("\\private\\two\\moo")); 
   889 		r=fMan->Copy(_L("\\capTest"),_L("\\private\\two\\moo")); 
   888 		test_Value(r, r == KErrPathNotFound);
 
   890 		test(r == KErrPathNotFound);
 
   889 		r=fMan->Copy(_L("\\capTest"),_L("\\sys\\bin\\moo")); 
   891 		r=fMan->Copy(_L("\\capTest"),_L("\\sys\\bin\\moo")); 
   890 		test_Value(r, r == KErrPathNotFound); 
   892 		test(r == KErrPathNotFound); 
   891 		r=fMan->Copy(_L("\\sys\\bin\\capTest"),_L("\\sys\\bin\\moo")); 
   893 		r=fMan->Copy(_L("\\sys\\bin\\capTest"),_L("\\sys\\bin\\moo")); 
   892 		test_Value(r, r == KErrPathNotFound);
 
   894 		test(r == KErrPathNotFound);
 
   893 		r=fMan->Copy(_L("\\capTest"),_L("\\sys\\capTest")); 
   895 		r=fMan->Copy(_L("\\capTest"),_L("\\sys\\capTest")); 
   894 		test_Value(r, r == KErrNone || r==KErrAlreadyExists); 
   896 		test(r == KErrNone || r==KErrAlreadyExists); 
   895 		r=fMan->Copy(_L("\\sys\\*"),_L("\\"));
 
   897 		r=fMan->Copy(_L("\\sys\\*"),_L("\\"));
 
   896 		test_KErrNone(r);
 
   898 		test (r==KErrNone);
 
   897 		r=fMan->Copy(name,_L("\\sys\\"));
 
   899 		r=fMan->Copy(name,_L("\\sys\\"));
 
   898 		test_KErrNone(r);
 
   900 		test(r==KErrNone);
 
   899 
   901 
   900 		// Testing Attribs
 
   902 		// Testing Attribs
 
   901 		r=fMan->Attribs(_L("\\private\\two\\moo"),KEntryAttReadOnly,0,TTime(0)); 
   903 		r=fMan->Attribs(_L("\\private\\two\\moo"),KEntryAttReadOnly,0,TTime(0)); 
   902 		test_Value(r, r == KErrPathNotFound);
 
   904 		test(r == KErrPathNotFound);
 
   903 		r=fMan->Attribs(_L("\\private\\moo"),KEntryAttReadOnly,0,TTime(0)); 
   905 		r=fMan->Attribs(_L("\\private\\moo"),KEntryAttReadOnly,0,TTime(0)); 
   904 		test_Value(r, r == KErrNotFound);
 
   906 		test(r == KErrNotFound);
 
   905 		r=fMan->Attribs(name,KEntryAttReadOnly,0,TTime(0));
 
   907 		r=fMan->Attribs(name,KEntryAttReadOnly,0,TTime(0));
 
   906 		test_KErrNone(r);
 
   908 		test(r == KErrNone);
 
   907 		r=fMan->Attribs(name,0,KEntryAttReadOnly,TTime(0));
 
   909 		r=fMan->Attribs(name,0,KEntryAttReadOnly,TTime(0));
 
   908 		test_KErrNone(r);
 
   910 		test(r == KErrNone);
 
   909 
   911 
   910 		// Testing Move
 
   912 		// Testing Move
 
   911 		r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo"));
 
   913 		r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo"));
 
   912 		test_Value(r, r == KErrPathNotFound);
 
   914 		test(r == KErrPathNotFound);
 
   913 		r=fMan->Move(_L("\\private\\two\\moo.."),_L("\\private\\one\\moo"));
 
   915 		r=fMan->Move(_L("\\private\\two\\moo.."),_L("\\private\\one\\moo"));
 
   914 		test_Value(r, r == KErrPathNotFound);
 
   916 		test(r == KErrPathNotFound);
 
   915 		r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo.."));
 
   917 		r=fMan->Move(_L("\\private\\two\\moo"),_L("\\private\\one\\moo.."));
 
   916 		test_Value(r, r == KErrPathNotFound);
 
   918 		test(r == KErrPathNotFound);
 
   917 		r=fMan->Move(name,_L("\\privateFile.tst"));
 
   919 		r=fMan->Move(name,_L("\\privateFile.tst"));
 
   918 		test_KErrNone(r);
 
   920 		test(r == KErrNone);
 
   919 		r=fMan->Move(_L("\\privateFile.tst"),name);
 
   921 		r=fMan->Move(_L("\\privateFile.tst"),name);
 
   920 		test_KErrNone(r);
 
   922 		test(r == KErrNone);
 
   921 
   923 
   922 
   924 
   923 		// Testing RmDir
 
   925 		// Testing RmDir
 
   924 		r=fMan->RmDir(_L("\\private\\"));
 
   926 		r=fMan->RmDir(_L("\\private\\"));
 
   925 		test_KErrNone(r);
 
   927 		test(r == KErrNone);
 
   926 		// put it back where it was
 
   928 		// put it back where it was
 
   927 		r = TheFs.MkDirAll(_L("\\private\\00000001\\"));
 
   929 		r = TheFs.MkDirAll(_L("\\private\\00000001\\"));
 
   928 		test_KErrNone(r);
 
   930 		test(r == KErrNone);
 
   929 		r=fMan->RmDir(_L("\\private\\two\\"));
 
   931 		r=fMan->RmDir(_L("\\private\\two\\"));
 
   930 		test_Value(r, r == KErrPathNotFound);
 
   932 		test(r == KErrPathNotFound);
 
   931 		r=fMan->RmDir(_L("\\private\\tw?\\"));
 
   933 		r=fMan->RmDir(_L("\\private\\tw?\\"));
 
   932 		test_Value(r, r == KErrBadName);
 
   934 		test(r == KErrBadName);
 
   933 
   935 
   934 		r=fMan->RmDir(_L("\\private\\two\\"));
 
   936 		r=fMan->RmDir(_L("\\private\\two\\"));
 
   935 		test_Value(r, r == KErrPathNotFound);
 
   937 		test(r == KErrPathNotFound);
 
   936 		r=fMan->RmDir(_L("\\private\\tw?\\"));
 
   938 		r=fMan->RmDir(_L("\\private\\tw?\\"));
 
   937 		test_Value(r, r == KErrBadName);
 
   939 		test(r == KErrBadName);
 
   938 		
   940 		
   939 		
   941 		
   940 		// Testing Rename
 
   942 		// Testing Rename
 
   941 		r=fMan->Rename(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); 
   943 		r=fMan->Rename(_L("\\private\\two\\moo"),_L("\\private\\two\\mew")); 
   942 		test_Value(r, r == KErrPathNotFound);
 
   944 		test(r == KErrPathNotFound);
 
   943 		
   945 		
   944 		// Testing Delete
 
   946 		// Testing Delete
 
   945 		r=fMan->Delete(_L("\\private\\two\\test")); 
   947 		r=fMan->Delete(_L("\\private\\two\\test")); 
   946 		test_Value(r, r == KErrPathNotFound);
 
   948 		test(r == KErrPathNotFound);
 
   947 		r=fMan->Delete(_L("\\private\\moo")); 
   949 		r=fMan->Delete(_L("\\private\\moo")); 
   948 		test_Value(r, r == KErrNotFound);
 
   950 		test(r == KErrNotFound);
 
   949 		
   951 		
   950 		//Something that actually exists in Private
 
   952 		//Something that actually exists in Private
 
   951 		r=fMan->Rename(name,_L("\\private\\00000001\\moo")); 
   953 		r=fMan->Rename(name,_L("\\private\\00000001\\moo")); 
   952 		test_Value(r, r == KErrNotFound);
 
   954 		test(r == KErrNotFound);
 
   953 		r=fMan->Rename(_L("\\private\\00000001\\moo"),name); 
   955 		r=fMan->Rename(_L("\\private\\00000001\\moo"),name); 
   954 		test_Value(r, r == KErrNotFound);
 
   956 		test(r == KErrNotFound);
 
   955 		r=fMan->Copy(name,_L("\\private\\00000001\\moo")); 
   957 		r=fMan->Copy(name,_L("\\private\\00000001\\moo")); 
   956 		test_Value(r, r == KErrNotFound);
 
   958 		test(r == KErrNotFound);
 
   957 		r=fMan->Delete(_L("\\private\\00000001\\moo")); 
   959 		r=fMan->Delete(_L("\\private\\00000001\\moo")); 
   958 		test_Value(r, r == KErrNotFound);
 
   960 		test(r == KErrNotFound);
 
   959 
   961 
   960 		// Clean up the test data
 
   962 		// Clean up the test data
 
   961 		r=fMan->RmDir(_L("\\Caged\\")); 
   963 		r=fMan->RmDir(_L("\\Caged\\")); 
   962 		test_KErrNone(r);
 
   964 		test(r == KErrNone);
 
   963 		r=fMan->Delete(_L("\\capTest")); 
   965 		r=fMan->Delete(_L("\\capTest")); 
   964 		test_KErrNone(r);
 
   966 		test(r == KErrNone);
 
   965 		delete(fMan);
 
   967 		delete(fMan);
 
   966 		}
 
   968 		}
 
   967 	
   969 	
   968 	// CDirScan tests
 
   970 	// CDirScan tests
 
   969 	ScanDir(_L("\\"), CDirScan::EScanUpTree, KErrNone);
 
   971 	ScanDir(_L("\\"), CDirScan::EScanUpTree, KErrNone);
 
   980 //
 
   982 //
 
   981 	{
 
   983 	{
 
   982 	test.Next(_L("Delete test directory"));
 
   984 	test.Next(_L("Delete test directory"));
 
   983 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   985 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   984 	TInt r=fMan->RmDir(gSessionPath);
 
   986 	TInt r=fMan->RmDir(gSessionPath);
 
   985 	test_Value(r, r == KErrNone || r == KErrPathNotFound);
 
   987 	test(r==KErrNone || KErrPathNotFound);
 
   986 	delete fMan;
 
   988 	delete fMan;
 
   987 	}
 
   989 	}
 
   988 
   990 
   989 GLDEF_C void CallTestsL(/*TChar aDriveLetter*/)
 
   991 GLDEF_C void CallTestsL(/*TChar aDriveLetter*/)
 
   990 //
 
   992 //
 
  1004 	TBuf<30> sesspath;
 
  1006 	TBuf<30> sesspath;
 
  1005 	sesspath=_L("?:\\");
 
  1007 	sesspath=_L("?:\\");
 
  1006 	sesspath[0] = (TText)gDriveToTest;
 
  1008 	sesspath[0] = (TText)gDriveToTest;
 
  1007 
  1009 
  1008 	TInt r= TheFs.SetSessionPath(sesspath);
 
  1010 	TInt r= TheFs.SetSessionPath(sesspath);
 
  1009 	test_KErrNone(r);
 
  1011 	test(r==KErrNone);
 
  1010 
  1012 
  1011 	//cleanup from previous run of this test
 
  1013 	//cleanup from previous run of this test
 
  1012 	TBuf<20> delDir;
 
  1014 	TBuf<20> delDir;
 
  1013 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
  1015 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
  1014 	delDir=KResourcePath;
 
  1016 	delDir=KResourcePath;
 
  1015 	delDir[0]=(TText)gDriveToTest;
 
  1017 	delDir[0]=(TText)gDriveToTest;
 
  1016 	r=fMan->RmDir(delDir);
 
  1018 	r=fMan->RmDir(delDir);
 
  1017 	test_Value(r, r == KErrNone || r == KErrNotFound || r == KErrPathNotFound);
 
  1019 	test(r==KErrNone || KErrNotFound);
 
  1018 	delDir=KSystemPath;
 
  1020 	delDir=KSystemPath;
 
  1019 	delDir[0]=(TText)gDriveToTest;
 
  1021 	delDir[0]=(TText)gDriveToTest;
 
  1020 	r=fMan->RmDir(delDir);
 
  1022 	r=fMan->RmDir(delDir);
 
  1021 	test_Value(r, r == KErrNone || r == KErrNotFound || r == KErrPathNotFound);
 
  1023 	test(r==KErrNone || KErrNotFound);
 
  1022 	delDir=KPrivatePath;
 
  1024 	delDir=KPrivatePath;
 
  1023 	delDir[0]=(TText)gDriveToTest;
 
  1025 	delDir[0]=(TText)gDriveToTest;
 
  1024 	r=fMan->RmDir(delDir);
 
  1026 	r=fMan->RmDir(delDir);
 
  1025 	test_Value(r, r == KErrNone || r == KErrNotFound || r == KErrPathNotFound);
 
  1027 	test(r==KErrNone || KErrNotFound);
 
  1026 	delete fMan;
 
  1028 	delete fMan;
 
  1027 
  1029 
  1028 	//check double mode ie that Defpath still works	
  1030 	//check double mode ie that Defpath still works	
  1029 	RFs fs1;
 
  1031 	RFs fs1;
 
  1030 	RFs fs2;
 
  1032 	RFs fs2;
 
  1031 	
  1033 	
  1032 	r=fs1.Connect();
 
  1034 	r=fs1.Connect();
 
  1033 	test_KErrNone(r);
 
  1035 	test(r==KErrNone);
 
  1034 	r=fs1.SessionPath(sesspath);
 
  1036 	r=fs1.SessionPath(sesspath);
 
  1035 	test_KErrNone(r);
 
  1037 	test(r==KErrNone);
 
  1036 	test.Printf(_L("session1 Path=%S"),&sesspath);
 
  1038 	test.Printf(_L("session1 Path=%S"),&sesspath);
 
  1037 
  1039 
  1038 	TBuf<30> privatepath;
 
  1040 	TBuf<30> privatepath;
 
  1039 	r=fs1.SetSessionToPrivate(gTheDriveNum);
 
  1041 	r=fs1.SetSessionToPrivate(gTheDriveNum);
 
  1040 	test_KErrNone(r);
 
  1042 	test(r==KErrNone);
 
  1041 	r=fs1.PrivatePath(privatepath);
 
  1043 	r=fs1.PrivatePath(privatepath);
 
  1042 	test_KErrNone(r);
 
  1044 	test(r==KErrNone);
 
  1043 	r=privatepath.Compare(KExpectedPrivatePath());
 
  1045 	r=privatepath.Compare(KExpectedPrivatePath());
 
  1044 	test_Value(r, r == 0);
 
  1046 	test(r==0);
 
  1045 	r=fs1.SessionPath(sesspath);
 
  1047 	r=fs1.SessionPath(sesspath);
 
  1046 	test_KErrNone(r);
 
  1048 	test(r==KErrNone);
 
  1047 	r=privatepath.Compare(sesspath.Mid(KPathPosition));
 
  1049 	r=privatepath.Compare(sesspath.Mid(KPathPosition));
 
  1048 	test_Value(r, r == 0);
 
  1050 	test(r==0);
 
  1049 	r=fs1.CreatePrivatePath(gTheDriveNum);
 
  1051 	r=fs1.CreatePrivatePath(gTheDriveNum);
 
  1050 	test_KErrNone(r);
 
  1052 	test(r==KErrNone);
 
  1051 	fs1.Close();
 
  1053 	fs1.Close();
 
  1052 
  1054 
  1053 	r=fs2.Connect();
 
  1055 	r=fs2.Connect();
 
  1054 	test_KErrNone(r);
 
  1056 	test(r==KErrNone);
 
  1055 	r=fs2.SessionPath(sesspath);
 
  1057 	r=fs2.SessionPath(sesspath);
 
  1056 	test_KErrNone(r);
 
  1058 	test(r==KErrNone);
 
  1057 	test.Printf(_L("session2 Path=%S"),&sesspath);
 
  1059 	test.Printf(_L("session2 Path=%S"),&sesspath);
 
  1058 	fs2.Close();
 
  1060 	fs2.Close();
 
  1059 
  1061 
  1060 	TestCaps();
 
  1062 	TestCaps();
 
  1061 	TestCaging();
 
  1063 	TestCaging();
FCL/sf/os/kernelhwsrv