Mercurial Mercurial > oss > MCL > 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_dcdiskadminallfiles.cpp
branchRCL_3
changeset 44 3e88ff8f41d5
parent 43 c1f20ce4abcf
equal deleted inserted replaced
43:c1f20ce4abcf 44:3e88ff8f41d5 
    13 // Description:
 
    13 // Description:
 
    14 // f32test\server\t_dcdiskadminallfiles.cpp
 
    14 // f32test\server\t_dcdiskadminallfiles.cpp
 
    15 // 
    15 // 
    16 //
 
    16 //
 
    17 
    17 
    18 #define __E32TEST_EXTENSION__
 
       
    19 #include <f32file.h>
 
    18 #include <f32file.h>
 
    20 #include <e32test.h>
 
    19 #include <e32test.h>
 
    21 #include <e32std.h>
 
    20 #include <e32std.h>
 
    22 #include <e32std_private.h>
 
    21 #include <e32std_private.h>
 
    23 #include <e32def.h>
 
    22 #include <e32def.h>
 
    82 TRequestStatus aStat1;
 
    81 TRequestStatus aStat1;
 
    83 TRequestStatus aStat2;
 
    82 TRequestStatus aStat2;
 
    84 TRequestStatus aStat3;
 
    83 TRequestStatus aStat3;
 
    85 TRequestStatus aStat4;
 
    84 TRequestStatus aStat4;
 
    86 
    85 
       
    86 TVolumeInfo aVolInfo;
 
       
    87 //	TDriveInfo adriveInfo;
 
       
    88 
    87 TBuf<40> systestfile;
 
    89 TBuf<40> systestfile;
 
    88 TBuf<40> pritestfile;
 
    90 TBuf<40> pritestfile;
 
    89 TBuf<40> restestfile;
 
    91 TBuf<40> restestfile;
 
    90 TBuf<40> systestfile1;
 
    92 TBuf<40> systestfile1;
 
    91 TBuf<40> pritestfile1;
 
    93 TBuf<40> pritestfile1;
 
   109 	
   111 	
   110 	mkdirname.Zero();
 
   112 	mkdirname.Zero();
 
   111 	mkdirname.Append(systestname);
 
   113 	mkdirname.Append(systestname);
 
   112 	mkdirname.Append(KMkDirSub);
 
   114 	mkdirname.Append(KMkDirSub);
 
   113 	r=TheFs.MkDirAll(mkdirname);	
   115 	r=TheFs.MkDirAll(mkdirname);	
   114 	test_Value(r, r == KErrPermissionDenied);
 
   116 	test(r==KErrPermissionDenied);
 
   115 
   117 
   116 	TheFs.RmDir(mkdirname);
 
   118 	TheFs.RmDir(mkdirname);
 
   117 	test_Value(r, r == KErrPermissionDenied);
 
   119 	test(r==KErrPermissionDenied);
 
   118 
   120 
   119 	r=TheFs.SetSubst(systestname,EDriveO);
 
   121 	r=TheFs.SetSubst(systestname,EDriveO);
 
   120 	test_Value(r, r == KErrPermissionDenied);
 
   122 	test(r==KErrPermissionDenied);
 
   121 	
   123 	
   122 	r=TheFs.SetSessionPath(systestname);
 
   124 	r=TheFs.SetSessionPath(systestname);
 
   123 	test_KErrNone(r);
 
   125 	test(r==KErrNone);
 
   124 	
   126 	
   125 	TheFs.NotifyChange(ENotifyAll,aStat1,systestname);
 
   127 	TheFs.NotifyChange(ENotifyAll,aStat1,systestname);
 
   126 	test(aStat1==KRequestPending);
 
   128 	test(aStat1==KRequestPending);
 
   127 
   129 
   128 	systestfile=KSystemPath;
 
   130 	systestfile=KSystemPath;
 
   133 	
   135 	
   134 	oldName=KOldFile;
 
   136 	oldName=KOldFile;
 
   135 	oldName[0]=(TText)gDriveToTest;
 
   137 	oldName[0]=(TText)gDriveToTest;
 
   136 
   138 
   137 	r=TheFs.GetShortName(systestfile, shortfilename);
 
   139 	r=TheFs.GetShortName(systestfile, shortfilename);
 
   138 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   140 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   139 
   141 
   140 	r=TheFs.GetLongName(systestfile1, longfilename);
 
   142 	r=TheFs.GetLongName(systestfile1, longfilename);
 
   141 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   143 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   142 
   144 
   143 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   145 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   144 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   146 	test(r==KErrNone || r==KErrAlreadyExists);
 
   145 	file1.Close();
 
   147 	file1.Close();
 
   146 
   148 
   147 	r=TheFs.Replace(oldName,systestfile);
 
   149 	r=TheFs.Replace(oldName,systestfile);
 
   148 	test_Value(r, r == KErrPermissionDenied);
 
   150 	test(r==KErrPermissionDenied);
 
   149 	
   151 	
   150 	r=TheFs.Rename(systestfile,systestfile1);
 
   152 	r=TheFs.Rename(systestfile,systestfile1);
 
   151 	test_Value(r, r == KErrPermissionDenied);
 
   153 	test(r==KErrPermissionDenied);
 
   152 	
   154 	
   153 	r=TheFs.Entry(systestfile1,entry);
 
   155 	r=TheFs.Entry(systestfile1,entry);
 
   154 	test_Value(r, r == KErrNone || r == KErrNotFound);
 
   156 	test(r==KErrNone || KErrNotFound);
 
   155 
   157 
   156 	r=TheFs.SetEntry(systestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   158 	r=TheFs.SetEntry(systestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   157 	test_Value(r, r == KErrPermissionDenied);
 
   159 	test(r==KErrPermissionDenied);
 
   158 
   160 
   159 	r=TheFs.Delete(systestfile1);
 
   161 	r=TheFs.Delete(systestfile1);
 
   160 	test_Value(r, r == KErrPermissionDenied);
 
   162 	test(r==KErrPermissionDenied);
 
   161 	}
 
   163 	}
 
   162 
   164 
   163 LOCAL_C void ResourceRFsTest()
 
   165 LOCAL_C void ResourceRFsTest()
 
   164 //
 
   166 //
 
   165 //
 
   167 //
 
   170 	
   172 	
   171 	mkdirname.Zero();
 
   173 	mkdirname.Zero();
 
   172 	mkdirname.Append(restestname);
 
   174 	mkdirname.Append(restestname);
 
   173 	mkdirname.Append(KMkDirSub);
 
   175 	mkdirname.Append(KMkDirSub);
 
   174 	r=TheFs.MkDirAll(mkdirname);	
   176 	r=TheFs.MkDirAll(mkdirname);	
   175 	test_Value(r, r == KErrPermissionDenied);
 
   177 	test(r==KErrPermissionDenied);
 
   176 
   178 
   177 	TheFs.RmDir(mkdirname);
 
   179 	TheFs.RmDir(mkdirname);
 
   178 	test_Value(r, r == KErrPermissionDenied);
 
   180 	test(r==KErrPermissionDenied);
 
   179 
   181 
   180 	// Change due to defect DEF099546 fix
 
   182 	// Change due to defect DEF099546 fix
 
   181 	// TCB capability is required for following operation.
 
   183 	// TCB capability is required for following operation.
 
   182 	r=TheFs.SetSubst(restestname,EDriveO);
 
   184 	r=TheFs.SetSubst(restestname,EDriveO);
 
   183 	//test_KErrNone(r);
 
   185 	//test(r==KErrNone);
 
   184 	test_Value(r, r == KErrPermissionDenied);
 
   186 	test(r==KErrPermissionDenied);
 
   185 	
   187 	
   186 	// SetSubst will fail.
 
   188 	// SetSubst will fail.
 
   187 	//r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   189 	//r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   188 	//test_KErrNone(r);
 
   190 	//test(r==KErrNone);
 
   189 
   191 
   190 	//r=TheFs.SetSubst(_L(""),EDriveO); 
   192 	//r=TheFs.SetSubst(_L(""),EDriveO); 
   191 	//test_KErrNone(r);
 
   193 	//test(r==KErrNone);
 
   192 
   194 
   193 	r=TheFs.SetSessionPath(restestname);
 
   195 	r=TheFs.SetSessionPath(restestname);
 
   194 	test_KErrNone(r);
 
   196 	test(r==KErrNone);
 
   195 	
   197 	
   196 	TheFs.NotifyChange(ENotifyAll,aStat4,restestname);
 
   198 	TheFs.NotifyChange(ENotifyAll,aStat4,restestname);
 
   197 	test(aStat4==KRequestPending);
 
   199 	test(aStat4==KRequestPending);
 
   198 
   200 
   199 	restestfile=KResourcePath;
 
   201 	restestfile=KResourcePath;
 
   204 	
   206 	
   205 	oldName=KOldFile;
 
   207 	oldName=KOldFile;
 
   206 	oldName[0]=(TText)gDriveToTest;
 
   208 	oldName[0]=(TText)gDriveToTest;
 
   207 
   209 
   208 	r=TheFs.GetShortName(restestfile, shortfilename);
 
   210 	r=TheFs.GetShortName(restestfile, shortfilename);
 
   209 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   211 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   210 
   212 
   211 	r=TheFs.GetLongName(restestfile1, longfilename);
 
   213 	r=TheFs.GetLongName(restestfile1, longfilename);
 
   212 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   214 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   213 
   215 
   214 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   216 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   215 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   217 	test(r==KErrNone || r==KErrAlreadyExists);
 
   216 	file1.Close();
 
   218 	file1.Close();
 
   217 
   219 
   218 	r=TheFs.Replace(oldName,restestfile);
 
   220 	r=TheFs.Replace(oldName,restestfile);
 
   219 	test_Value(r, r == KErrPermissionDenied);
 
   221 	test(r==KErrPermissionDenied);
 
   220 	
   222 	
   221 	r=TheFs.Rename(restestfile,restestfile1);
 
   223 	r=TheFs.Rename(restestfile,restestfile1);
 
   222 	test_Value(r, r == KErrPermissionDenied);
 
   224 	test(r==KErrPermissionDenied);
 
   223 	
   225 	
   224 	r=TheFs.Entry(restestfile1,entry);
 
   226 	r=TheFs.Entry(restestfile1,entry);
 
   225 	test_Value(r, r == KErrNone || r==KErrPathNotFound || r==KErrNotFound);
 
   227 	test(r==KErrNone || r==KErrPathNotFound || r==KErrNotFound);
 
   226 
   228 
   227 	r=TheFs.SetEntry(restestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   229 	r=TheFs.SetEntry(restestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   228 	test_Value(r, r == KErrPermissionDenied);
 
   230 	test(r==KErrPermissionDenied);
 
   229 
   231 
   230 	r=TheFs.Delete(restestfile1);
 
   232 	r=TheFs.Delete(restestfile1);
 
   231 	test_Value(r, r == KErrPermissionDenied);
 
   233 	test(r==KErrPermissionDenied);
 
   232 
   234 
   233 	}
 
   235 	}
 
   234 
   236 
   235 
   237 
   236 LOCAL_C void privatefalseIDRFsTest()
 
   238 LOCAL_C void privatefalseIDRFsTest()
 
   244 	mkdirname.Zero();
 
   246 	mkdirname.Zero();
 
   245 	mkdirname.Append(pritestfalseidname);
 
   247 	mkdirname.Append(pritestfalseidname);
 
   246 	mkdirname.Append(KMkDirSub);
 
   248 	mkdirname.Append(KMkDirSub);
 
   247 
   249 
   248 	r=TheFs.MkDirAll(mkdirname);	
   250 	r=TheFs.MkDirAll(mkdirname);	
   249 	test_KErrNone(r);
 
   251 	test(r==KErrNone);
 
   250 
   252 
   251 	r=TheFs.RmDir(mkdirname);	
   253 	r=TheFs.RmDir(mkdirname);	
   252 	test_KErrNone(r);
 
   254 	test(r==KErrNone);
 
   253 
   255 
   254 	r=TheFs.SetSubst(pritestfalseidname,EDriveO);
 
   256 	r=TheFs.SetSubst(pritestfalseidname,EDriveO);
 
   255 	test_KErrNone(r);
 
   257 	test(r==KErrNone);
 
   256 
   258 
   257 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   259 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   258 	test_KErrNone(r);
 
   260 	test(r==KErrNone);
 
   259 
   261 
   260 	r=TheFs.SetSubst(_L(""),EDriveO);
 
   262 	r=TheFs.SetSubst(_L(""),EDriveO);
 
   261 	test_KErrNone(r);
 
   263 	test(r==KErrNone);
 
   262 
   264 
   263 	r=TheFs.SetSessionPath(pritestfalseidname);
 
   265 	r=TheFs.SetSessionPath(pritestfalseidname);
 
   264 	test_KErrNone(r);
 
   266 	test(r==KErrNone);
 
   265 
   267 
   266 	TheFs.NotifyChange(ENotifyAll,aStat2,pritestfalseidname);
 
   268 	TheFs.NotifyChange(ENotifyAll,aStat2,pritestfalseidname);
 
   267 	test(aStat2==KRequestPending);
 
   269 	test(aStat2==KRequestPending);
 
   268 
   270 
   269 
   271 
   275 	
   277 	
   276 	oldName=KOldFile;
 
   278 	oldName=KOldFile;
 
   277 	oldName[0]=(TText)gDriveToTest;
 
   279 	oldName[0]=(TText)gDriveToTest;
 
   278 
   280 
   279 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   281 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   280 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   282 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   281 
   283 
   282 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   284 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   283 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   285 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   284 
   286 
   285 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   287 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   286 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   288 	test(r==KErrNone || r==KErrAlreadyExists);
 
   287 	file1.Close();
 
   289 	file1.Close();
 
   288 
   290 
   289 	r=TheFs.Replace(oldName,pritestfile);
 
   291 	r=TheFs.Replace(oldName,pritestfile);
 
   290 	test_KErrNone(r);
 
   292 	test(r==KErrNone);
 
   291 	
   293 	
   292 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   294 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   293 	test_KErrNone(r);
 
   295 	test(r==KErrNone);
 
   294 	
   296 	
   295 	r=TheFs.Entry(pritestfile1,entry);
 
   297 	r=TheFs.Entry(pritestfile1,entry);
 
   296 	test_KErrNone(r);
 
   298 	test(r==KErrNone);
 
   297 
   299 
   298 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   300 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   299 	test_KErrNone(r);
 
   301 	test(r==KErrNone);
 
   300 
   302 
   301 	r=TheFs.Delete(pritestfile1);
 
   303 	r=TheFs.Delete(pritestfile1);
 
   302 	test_KErrNone(r);
 
   304 	test(r==KErrNone);
 
   303 
   305 
   304 	}
 
   306 	}
 
   305 
   307 
   306 
   308 
   307 LOCAL_C void privateRFsTest()
 
   309 LOCAL_C void privateRFsTest()
 
   316 	mkdirname.Zero();
 
   318 	mkdirname.Zero();
 
   317 	mkdirname.Append(pritestname);
 
   319 	mkdirname.Append(pritestname);
 
   318 	mkdirname.Append(KMkDirSub);
 
   320 	mkdirname.Append(KMkDirSub);
 
   319 
   321 
   320 	r=TheFs.MkDirAll(mkdirname);	
   322 	r=TheFs.MkDirAll(mkdirname);	
   321 	test_KErrNone(r);
 
   323 	test(r==KErrNone);
 
   322 
   324 
   323 	r=TheFs.RmDir(mkdirname);	
   325 	r=TheFs.RmDir(mkdirname);	
   324 	test_KErrNone(r);
 
   326 	test(r==KErrNone);
 
   325 
   327 
   326 	r=TheFs.SetSubst(pritestname,EDriveO);
 
   328 	r=TheFs.SetSubst(pritestname,EDriveO);
 
   327 	test_KErrNone(r);
 
   329 	test(r==KErrNone);
 
   328 
   330 
   329 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   331 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   330 	test_KErrNone(r);
 
   332 	test(r==KErrNone);
 
   331 
   333 
   332 	r=TheFs.SetSubst(_L(""),EDriveO);
 
   334 	r=TheFs.SetSubst(_L(""),EDriveO);
 
   333 	test_KErrNone(r);
 
   335 	test(r==KErrNone);
 
   334 
   336 
   335 	r=TheFs.SetSessionPath(pritestname);
 
   337 	r=TheFs.SetSessionPath(pritestname);
 
   336 	test_KErrNone(r);
 
   338 	test(r==KErrNone);
 
   337 
   339 
   338 	TheFs.NotifyChange(ENotifyAll,aStat2,pritestname);
 
   340 	TheFs.NotifyChange(ENotifyAll,aStat2,pritestname);
 
   339 	test(aStat2==KRequestPending);
 
   341 	test(aStat2==KRequestPending);
 
   340 
   342 
   341 
   343 
   347 	
   349 	
   348 	oldName=KOldFile;
 
   350 	oldName=KOldFile;
 
   349 	oldName[0]=(TText)gDriveToTest;
 
   351 	oldName[0]=(TText)gDriveToTest;
 
   350 
   352 
   351 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   353 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   352 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   354 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   353 
   355 
   354 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   356 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   355 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   357 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   356 
   358 
   357 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   359 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   358 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   360 	test(r==KErrNone || r==KErrAlreadyExists);
 
   359 	file1.Close();
 
   361 	file1.Close();
 
   360 
   362 
   361 	r=TheFs.Replace(oldName,pritestfile);
 
   363 	r=TheFs.Replace(oldName,pritestfile);
 
   362 	test_Value(r, r == KErrNone || r==KErrNotFound);
 
   364 	test(r==KErrNone || r==KErrNotFound);
 
   363 	
   365 	
   364 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   366 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   365 	test_KErrNone(r);
 
   367 	test(r==KErrNone);
 
   366 	
   368 	
   367 	r=TheFs.Entry(pritestfile1,entry);
 
   369 	r=TheFs.Entry(pritestfile1,entry);
 
   368 	test_KErrNone(r);
 
   370 	test(r==KErrNone);
 
   369 
   371 
   370 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   372 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   371 	test_KErrNone(r);
 
   373 	test(r==KErrNone);
 
   372 
   374 
   373 	r=TheFs.Delete(pritestfile1);
 
   375 	r=TheFs.Delete(pritestfile1);
 
   374 	test_KErrNone(r);
 
   376 	test(r==KErrNone);
 
   375 
   377 
   376 	}
 
   378 	}
 
   377 
   379 
   378 
   380 
   379 LOCAL_C void privateSIDRFstest()
 
   381 LOCAL_C void privateSIDRFstest()
 
   383 
   385 
   384 	mkdirname.Zero();
 
   386 	mkdirname.Zero();
 
   385 	mkdirname.Append(theprivatepath);
 
   387 	mkdirname.Append(theprivatepath);
 
   386 	mkdirname.Append(KMkDirSub);
 
   388 	mkdirname.Append(KMkDirSub);
 
   387 	r=TheFs.MkDirAll(mkdirname);	
   389 	r=TheFs.MkDirAll(mkdirname);	
   388 	test_KErrNone(r);
 
   390 	test(r==KErrNone);
 
   389 
   391 
   390 	r=TheFs.RmDir(mkdirname);	
   392 	r=TheFs.RmDir(mkdirname);	
   391 	test_KErrNone(r);
 
   393 	test(r==KErrNone);
 
   392 
   394 
   393 	r=TheFs.SetSubst(theprivatepath,EDriveO);	
   395 	r=TheFs.SetSubst(theprivatepath,EDriveO);	
   394 	test_KErrNone(r);
 
   396 	test(r==KErrNone);
 
   395 
   397 
   396 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   398 	r=TheFs.RealName(_L("O:\\File.XXX"),realName);
 
   397 	test_KErrNone(r);
 
   399 	test(r==KErrNone);
 
   398 
   400 
   399 	r=TheFs.SetSubst(_L(""),EDriveO);	
   401 	r=TheFs.SetSubst(_L(""),EDriveO);	
   400 	test_KErrNone(r);
 
   402 	test(r==KErrNone);
 
   401 
   403 
   402 	r=TheFs.SetSessionPath(theprivatepath);
 
   404 	r=TheFs.SetSessionPath(theprivatepath);
 
   403 	test_KErrNone(r);
 
   405 	test(r==KErrNone);
 
   404 
   406 
   405 	TheFs.NotifyChange(ENotifyAll,aStat3,theprivatepath);
 
   407 	TheFs.NotifyChange(ENotifyAll,aStat3,theprivatepath);
 
   406 	test(aStat3==KRequestPending);
 
   408 	test(aStat3==KRequestPending);
 
   407 
   409 
   408 	pritestfile=theprivatepath;
 
   410 	pritestfile=theprivatepath;
 
   413 	
   415 	
   414 	oldName=KOldFile;
 
   416 	oldName=KOldFile;
 
   415 	oldName[0]=(TText)gDriveToTest;
 
   417 	oldName[0]=(TText)gDriveToTest;
 
   416 
   418 
   417 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   419 	r=TheFs.GetShortName(pritestfile, shortfilename);
 
   418 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   420 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   419 
   421 
   420 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   422 	r=TheFs.GetLongName(pritestfile1, longfilename);
 
   421 	test_Value(r, r == KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   423 	test(r==KErrNone || r==KErrNotFound || r==KErrNotSupported);
 
   422 
   424 
   423 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   425 	r=file1.Create(TheFs,oldName,EFileWrite);
 
   424 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   426 	test(r==KErrNone || r==KErrAlreadyExists);
 
   425 	file1.Close();
 
   427 	file1.Close();
 
   426 
   428 
   427 	r=TheFs.Replace(oldName,pritestfile);
 
   429 	r=TheFs.Replace(oldName,pritestfile);
 
   428 	test_KErrNone(r);
 
   430 	test(r==KErrNone);
 
   429 	
   431 	
   430 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   432 	r=TheFs.Rename(pritestfile,pritestfile1);
 
   431 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   433 	test(r==KErrNone || r==KErrAlreadyExists);
 
   432 	
   434 	
   433 	r=TheFs.Entry(pritestfile1,entry);
 
   435 	r=TheFs.Entry(pritestfile1,entry);
 
   434 	test_KErrNone(r);
 
   436 	test(r==KErrNone);
 
   435 
   437 
   436 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   438 	r=TheFs.SetEntry(pritestfile1,testtime,KEntryAttNormal,KEntryAttReadOnly);
 
   437 	test_KErrNone(r);
 
   439 	test(r==KErrNone);
 
   438 
   440 
   439 	r=TheFs.Delete(pritestfile1);
 
   441 	r=TheFs.Delete(pritestfile1);
 
   440 	test_KErrNone(r);
 
   442 	test(r==KErrNone);
 
   441 	}
 
   443 	}
 
   442 
   444 
   443 
   445 
   444 LOCAL_C void systemRFiletest()
 
   446 LOCAL_C void systemRFiletest()
 
   445 //
 
   447 //
 
   446 //RFile testing with session path set to //system//
 
   448 //RFile testing with session path set to //system//
 
   447 //
 
   449 //
 
   448 	{
 
   450 	{
 
   449 
   451 
   450 	r=TheFs.SetSessionPath(systestname);
 
   452 	r=TheFs.SetSessionPath(systestname);
 
   451 	test_KErrNone(r);
 
   453 	test(r==KErrNone);
 
   452 
   454 
   453 	r=file1.Temp(TheFs,systestname,fromTemp,EFileWrite);
 
   455 	r=file1.Temp(TheFs,systestname,fromTemp,EFileWrite);
 
   454 	test_Value(r, r == KErrPermissionDenied);
 
   456 	test(r==KErrPermissionDenied);
 
   455 	file1.Close();
 
   457 	file1.Close();
 
   456 	
   458 	
   457 	systestfile=systestname;
 
   459 	systestfile=systestname;
 
   458 	systestfile.Append(KFileSys);
 
   460 	systestfile.Append(KFileSys);
 
   459 	r=file1.Create(TheFs,systestfile,EFileWrite);
 
   461 	r=file1.Create(TheFs,systestfile,EFileWrite);
 
   460 	test_Value(r, r == KErrPermissionDenied);
 
   462 	test(r==KErrPermissionDenied);
 
   461 	file1.Close();
 
   463 	file1.Close();
 
   462 
   464 
   463 	r=file1.Open(TheFs,systestfile,EFileWrite);
 
   465 	r=file1.Open(TheFs,systestfile,EFileWrite);
 
   464 	test_Value(r, r == KErrPermissionDenied);
 
   466 	test(r==KErrPermissionDenied);
 
   465 
   467 
   466 	r=file1.Open(TheFs,systestfile,EFileRead);
 
   468 	r=file1.Open(TheFs,systestfile,EFileRead);
 
   467 	test_Value(r, r == KErrNone|| r==KErrNotFound);
 
   469 	test(r==KErrNone|| r==KErrNotFound);
 
   468 	
   470 	
   469 	r=file1.Replace(TheFs,systestfile,EFileWrite);
 
   471 	r=file1.Replace(TheFs,systestfile,EFileWrite);
 
   470 	test_Value(r, r == KErrPermissionDenied);
 
   472 	test(r==KErrPermissionDenied);
 
   471 	
   473 	
   472     TFindFile finder(TheFs);
 
   474     TFindFile finder(TheFs);
 
   473     CDir* dir = NULL;
 
   475     CDir* dir = NULL;
 
   474     r=finder.FindWildByDir(KWildFile, KWildPath, dir);
 
   476     r=finder.FindWildByDir(KWildFile, KWildPath, dir);
 
   475 	if (!(r==KErrNone))
 
   477 	if (!(r==KErrNone))
 
   476         test.Printf(_L("T_DCDISKADMINALLFILES: test find wildcards r = %d (expected KErrNone)\n"), r);
 
   478         test.Printf(_L("T_DCDISKADMINALLFILES: test find wildcards r = %d (expected KErrNone)\n"), r);
 
   477 	test_KErrNone(r);
 
   479 	test(r==KErrNone);
 
   478 	delete dir;
 
   480 	delete dir;
 
   479 	}
 
   481 	}
 
   480 
   482 
   481 LOCAL_C void resourceRFiletest()
 
   483 LOCAL_C void resourceRFiletest()
 
   482 //
 
   484 //
 
   483 //RFile testing with session path set to //resource//
 
   485 //RFile testing with session path set to //resource//
 
   484 //
 
   486 //
 
   485 	{
 
   487 	{
 
   486 	r=TheFs.SetSessionPath(restestname);
 
   488 	r=TheFs.SetSessionPath(restestname);
 
   487 	test_KErrNone(r);
 
   489 	test(r==KErrNone);
 
   488 
   490 
   489 	r=file1.Temp(TheFs,restestname,fromTemp,EFileWrite);
 
   491 	r=file1.Temp(TheFs,restestname,fromTemp,EFileWrite);
 
   490 	test_Value(r, r == KErrPermissionDenied);
 
   492 	test(r==KErrPermissionDenied);
 
   491 	file1.Close();
 
   493 	file1.Close();
 
   492 
   494 
   493 	r=file1.Create(TheFs,KFileRes,EFileWrite);
 
   495 	r=file1.Create(TheFs,KFileRes,EFileWrite);
 
   494 	test_Value(r, r == KErrPermissionDenied);
 
   496 	test(r==KErrPermissionDenied);
 
   495 	file1.Close();
 
   497 	file1.Close();
 
   496 
   498 
   497 	r=file1.Open(TheFs,KFileRes,EFileWrite|EFileShareExclusive );
 
   499 	r=file1.Open(TheFs,KFileRes,EFileWrite|EFileShareExclusive );
 
   498 	test_Value(r, r == KErrPermissionDenied);
 
   500 	test(r==KErrPermissionDenied);
 
   499 	
   501 	
   500 	r=file1.Open(TheFs,KFileRes,EFileShareReadersOnly);
 
   502 	r=file1.Open(TheFs,KFileRes,EFileShareReadersOnly);
 
   501 	test_Value(r, r == KErrNone || r == KErrPathNotFound || r == KErrNotFound);
 
   503 	test(r==KErrNone || KErrPathNotFound || KErrNotFound);
 
   502 	file1.Close();
 
   504 	file1.Close();
 
   503 
   505 
   504 	r=file1.Open(TheFs,KFileRes,EFileShareReadersOrWriters|EFileRead);
 
   506 	r=file1.Open(TheFs,KFileRes,EFileShareReadersOrWriters|EFileRead);
 
   505 	test_Value(r, r == KErrNone || r == KErrPathNotFound || r == KErrNotFound);
 
   507 	test(r==KErrNone || KErrPathNotFound || KErrNotFound);
 
   506 	file1.Close();
 
   508 	file1.Close();
 
   507 
   509 
   508 	r=file1.Open(TheFs,KFileRes,EFileShareReadersOrWriters|EFileWrite);
 
   510 	r=file1.Open(TheFs,KFileRes,EFileShareReadersOrWriters|EFileWrite);
 
   509 	test_Value(r, r == KErrPermissionDenied);
 
   511 	test(r==KErrPermissionDenied);
 
   510 	file1.Close();
 
   512 	file1.Close();
 
   511 	
   513 	
   512 	r=file1.Replace(TheFs,KFileRes3,EFileWrite);
 
   514 	r=file1.Replace(TheFs,KFileRes3,EFileWrite);
 
   513 	test_Value(r, r == KErrPermissionDenied);
 
   515 	test(r==KErrPermissionDenied);
 
   514 	file1.Close();
 
   516 	file1.Close();
 
   515 	}
 
   517 	}
 
   516 
   518 
   517 
   519 
   518 LOCAL_C void privatefalseIDRFiletest()
 
   520 LOCAL_C void privatefalseIDRFiletest()
 
   519 //
 
   521 //
 
   520 //RFile testing with session path set to //Private//false ID
 
   522 //RFile testing with session path set to //Private//false ID
 
   521 //
 
   523 //
 
   522 	{
 
   524 	{
 
   523 	r=TheFs.SetSessionPath(pritestfalseidname);
 
   525 	r=TheFs.SetSessionPath(pritestfalseidname);
 
   524 	test_KErrNone(r);
 
   526 	test(r==KErrNone);
 
   525 
   527 
   526 	r=file1.Temp(TheFs,pritestfalseidname,fromTemp,EFileWrite);
 
   528 	r=file1.Temp(TheFs,pritestfalseidname,fromTemp,EFileWrite);
 
   527 	test_KErrNone(r);
 
   529 	test(r==KErrNone);
 
   528 	file1.Close();
 
   530 	file1.Close();
 
   529 
   531 
   530 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   532 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   531 	test_KErrNone(r);
 
   533 	test(r==KErrNone);
 
   532 	file1.Close();
 
   534 	file1.Close();
 
   533 
   535 
   534 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   536 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   535 	test_KErrNone(r);
 
   537 	test(r==KErrNone);
 
   536 	file1.Close();
 
   538 	file1.Close();
 
   537 	
   539 	
   538 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   540 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   539 	test_KErrNone(r);
 
   541 	test(r==KErrNone);
 
   540 	file1.Close();
 
   542 	file1.Close();
 
   541 	
   543 	
   542 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   544 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   543 	test_KErrNone(r);
 
   545 	test(r==KErrNone);
 
   544 	
   546 	
   545 	r=file1.Rename(KFilePri3);
 
   547 	r=file1.Rename(KFilePri3);
 
   546 	test_KErrNone(r);
 
   548 	test(r==KErrNone);
 
   547 	file1.Close();
 
   549 	file1.Close();
 
   548 	}
 
   550 	}
 
   549 
   551 
   550 
   552 
   551 LOCAL_C void privateRFiletest()
 
   553 LOCAL_C void privateRFiletest()
 
   552 //
 
   554 //
 
   553 //RFile testing with session path set to //Private//
 
   555 //RFile testing with session path set to //Private//
 
   554 //
 
   556 //
 
   555 	{
 
   557 	{
 
   556 	r=TheFs.SetSessionPath(pritestname);
 
   558 	r=TheFs.SetSessionPath(pritestname);
 
   557 	test_KErrNone(r);
 
   559 	test(r==KErrNone);
 
   558 
   560 
   559 	r=file1.Temp(TheFs,pritestname,fromTemp,EFileWrite);
 
   561 	r=file1.Temp(TheFs,pritestname,fromTemp,EFileWrite);
 
   560 	test_KErrNone(r);
 
   562 	test(r==KErrNone);
 
   561 	file1.Close();
 
   563 	file1.Close();
 
   562 
   564 
   563 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   565 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   564 	test_KErrNone(r);
 
   566 	test(r==KErrNone);
 
   565 	file1.Close();
 
   567 	file1.Close();
 
   566 
   568 
   567 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   569 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   568 	test_KErrNone(r);
 
   570 	test(r==KErrNone);
 
   569 	file1.Close();
 
   571 	file1.Close();
 
   570 	
   572 	
   571 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   573 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   572 	test_KErrNone(r);
 
   574 	test(r==KErrNone);
 
   573 	file1.Close();
 
   575 	file1.Close();
 
   574 
   576 
   575 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   577 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   576 	test_KErrNone(r);
 
   578 	test(r==KErrNone);
 
   577 	
   579 	
   578 	r=file1.Rename(KFilePri3);
 
   580 	r=file1.Rename(KFilePri3);
 
   579 	test_KErrNone(r);
 
   581 	test(r==KErrNone);
 
   580 	file1.Close();
 
   582 	file1.Close();
 
   581 	}
 
   583 	}
 
   582 
   584 
   583 
   585 
   584 LOCAL_C void privateSIDRFiletest()
 
   586 LOCAL_C void privateSIDRFiletest()
 
   585 //
 
   587 //
 
   586 //Rfile Testing with session path set to //Private//UID//
 
   588 //Rfile Testing with session path set to //Private//UID//
 
   587 //
 
   589 //
 
   588 	{
 
   590 	{
 
   589 	r=TheFs.SetSessionToPrivate(gTheDriveNum);
 
   591 	r=TheFs.SetSessionToPrivate(gTheDriveNum);
 
   590 	test_KErrNone(r);
 
   592 	test(r==KErrNone);
 
   591 	
   593 	
   592 	r=file1.Temp(TheFs,theprivatepath,fromTemp,EFileWrite);
 
   594 	r=file1.Temp(TheFs,theprivatepath,fromTemp,EFileWrite);
 
   593 	test_KErrNone(r);
 
   595 	test(r==KErrNone);
 
   594 	file1.Close();
 
   596 	file1.Close();
 
   595 
   597 
   596 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   598 	r=file1.Create(TheFs,KFilePri,EFileWrite);
 
   597 	test_KErrNone(r);
 
   599 	test(r==KErrNone);
 
   598 	file1.Close();
 
   600 	file1.Close();
 
   599 
   601 
   600 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   602 	r=file1.Open(TheFs,KFilePri,EFileWrite);
 
   601 	test_KErrNone(r);
 
   603 	test(r==KErrNone);
 
   602 	file1.Close();
 
   604 	file1.Close();
 
   603 
   605 
   604 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   606 	r=file1.Open(TheFs,KFilePri,EFileRead);
 
   605 	test_KErrNone(r);
 
   607 	test(r==KErrNone);
 
   606 	file1.Close();
 
   608 	file1.Close();
 
   607 
   609 
   608 
   610 
   609 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   611 	r=file1.Replace(TheFs,KFilePri,EFileWrite);
 
   610 	test_KErrNone(r);
 
   612 	test(r==KErrNone);
 
   611 	
   613 	
   612 	r=file1.Rename(KFilePri3);
 
   614 	r=file1.Rename(KFilePri3);
 
   613 	test_KErrNone(r);
 
   615 	test(r==KErrNone);
 
   614 	file1.Close();
 
   616 	file1.Close();
 
   615 	}
 
   617 	}
 
   616 
   618 
   617 LOCAL_C void RDirtest()
 
   619 LOCAL_C void RDirtest()
 
   618 //
 
   620 //
 
   623 	//system
 
   625 	//system
 
   624 	CDir*	dirEntries;
 
   626 	CDir*	dirEntries;
 
   625 	TBuf<30> dirNameBuf(KSystemPath);
 
   627 	TBuf<30> dirNameBuf(KSystemPath);
 
   626 	dirNameBuf[0]=(TText)gDriveToTest;
 
   628 	dirNameBuf[0]=(TText)gDriveToTest;
 
   627 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   629 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   628 	test_Value(r, r == KErrNone || r==KErrPathNotFound || r==KErrNotFound);
 
   630 	test(r==KErrNone || r==KErrPathNotFound || r==KErrNotFound);
 
   629 	dir.Close();
 
   631 	dir.Close();
 
   630 	if(r==KErrNone)
 
   632 	if(r==KErrNone)
 
   631 		{
 
   633 		{
 
   632 		r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   634 		r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   633 		test_KErrNone(r);
 
   635 		test(r==KErrNone);
 
   634 		delete dirEntries;
 
   636 		delete dirEntries;
 
   635 		}
 
   637 		}
 
   636 	dirNameBuf.Zero();
 
   638 	dirNameBuf.Zero();
 
   637 	//Private//falseID
 
   639 	//Private//falseID
 
   638 	dirNameBuf=KPrivateFalseID;
 
   640 	dirNameBuf=KPrivateFalseID;
 
   639 	dirNameBuf[0]=(TText)gDriveToTest;
 
   641 	dirNameBuf[0]=(TText)gDriveToTest;
 
   640 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   642 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   641 	test_KErrNone(r);
 
   643 	test(r==KErrNone);
 
   642 	dir.Close();
 
   644 	dir.Close();
 
   643 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   645 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   644 	test_KErrNone(r);
 
   646 	test(r==KErrNone);
 
   645 	dirNameBuf.Zero();
 
   647 	dirNameBuf.Zero();
 
   646 	delete dirEntries;
 
   648 	delete dirEntries;
 
   647 	//Private
 
   649 	//Private
 
   648 	dirNameBuf=KPrivatePath;
 
   650 	dirNameBuf=KPrivatePath;
 
   649 	dirNameBuf[0]=(TText)gDriveToTest;
 
   651 	dirNameBuf[0]=(TText)gDriveToTest;
 
   650 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   652 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   651 	test_KErrNone(r);
 
   653 	test(r==KErrNone);
 
   652 	dir.Close();
 
   654 	dir.Close();
 
   653 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   655 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   654 	test_KErrNone(r);
 
   656 	test(r==KErrNone);
 
   655 	dirNameBuf.Zero();
 
   657 	dirNameBuf.Zero();
 
   656 	delete dirEntries;
 
   658 	delete dirEntries;
 
   657 	//Private/uid
 
   659 	//Private/uid
 
   658 	TheFs.PrivatePath(dirNameBuf);
 
   660 	TheFs.PrivatePath(dirNameBuf);
 
   659 	dirNameBuf.Insert(0,_L("?:"));
 
   661 	dirNameBuf.Insert(0,_L("?:"));
 
   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 	dir.Close();
 
   665 	dir.Close();
 
   664 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   666 	r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   665 	test_KErrNone(r);
 
   667 	test(r==KErrNone);
 
   666 	dirNameBuf.Zero();
 
   668 	dirNameBuf.Zero();
 
   667 	delete dirEntries;
 
   669 	delete dirEntries;
 
   668 	//Resource
 
   670 	//Resource
 
   669 	dirNameBuf=KResourcePath;
 
   671 	dirNameBuf=KResourcePath;
 
   670 	dirNameBuf[0]=(TText)gDriveToTest;
 
   672 	dirNameBuf[0]=(TText)gDriveToTest;
 
   671 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   673 	r=dir.Open(TheFs,dirNameBuf,KEntryAttNormal);
 
   672 	test_Value(r, r == KErrNone || r==KErrPathNotFound);
 
   674 	test(r==KErrNone || r==KErrPathNotFound);
 
   673 	if(r==KErrNone)
 
   675 	if(r==KErrNone)
 
   674 		{
 
   676 		{
 
   675 		r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   677 		r=TheFs.GetDir(dirNameBuf,KEntryAttMatchMask,ESortByName,dirEntries);
 
   676 		test_KErrNone(r);
 
   678 		test(r==KErrNone);
 
   677 		dir.Close();
 
   679 		dir.Close();
 
   678 		delete dirEntries;
 
   680 		delete dirEntries;
 
   679 		}
 
   681 		}
 
   680 	}
 
   682 	}
 
   681 
   683 
   684 //
 
   686 //
 
   685 //	Test with root capabilities
 
   687 //	Test with root capabilities
 
   686 //
 
   688 //
 
   687 	{
 
   689 	{
 
   688 	r=TheFs.FileSystemName(fsname,gTheDriveNum);
 
   690 	r=TheFs.FileSystemName(fsname,gTheDriveNum);
 
   689 	test_KErrNone(r);	
   691 	test(r==KErrNone);	
   690 	r = DismountFileSystem(TheFs, fsname, gTheDriveNum);
 
   692 	r = DismountFileSystem(TheFs, fsname, gTheDriveNum);
 
   691 	test_KErrNone(r);
 
   693 	test(r==KErrNone);
 
   692 //	r=TheFs.RemoveFileSystem(fsname);	//can not test due to bug else where fix exists
 
   694 //	r=TheFs.RemoveFileSystem(fsname);	//can not test due to bug else where fix exists
 
   693 //	test_KErrNone(r);
 
   695 //	test(r==KErrNone);
 
   694 //	r=TheFs.AddFileSystem(fsname);
 
   696 //	r=TheFs.AddFileSystem(fsname);
 
   695 //	test_KErrNone(r);
 
   697 //	test(r==KErrNone);
 
   696 	r = MountFileSystem(TheFs, fsname, gTheDriveNum);
 
   698 	r = MountFileSystem(TheFs, fsname, gTheDriveNum);
 
   697 	test_KErrNone(r);
 
   699 	test(r==KErrNone);
 
   698 	r=TheFs.SetDriveName(gTheDriveNum,KDriveName);
 
   700 	r=TheFs.SetDriveName(gTheDriveNum,KDriveName);
 
   699 	test_KErrNone(r);
 
   701 	test(r==KErrNone);
 
   700 #ifndef __WINS__
 
   702 #ifndef __WINS__
 
   701  	r=TheFs.SetVolumeLabel(KVolLable, gTheDriveNum);
 
   703  	r=TheFs.SetVolumeLabel(KVolLable, gTheDriveNum);
 
   702 	test_KErrNone(r);
 
   704 	test(r==KErrNone);
 
   703 #endif
 
   705 #endif
 
   704 
   706 
   705 	systemRFsTest();
 
   707 	systemRFsTest();
 
   706 	ResourceRFsTest();
 
   708 	ResourceRFsTest();
 
   707 	privateRFsTest();	
   709 	privateRFsTest();	
   729 	test(aStat4 == KRequestPending);
 
   731 	test(aStat4 == KRequestPending);
 
   730 	TheFs.NotifyChangeCancel(aStat4);
 
   732 	TheFs.NotifyChangeCancel(aStat4);
 
   731 	test(aStat4==KErrCancel);
 
   733 	test(aStat4==KErrCancel);
 
   732 
   734 
   733 	r=TheFs.SetSessionPath(systestname);
 
   735 	r=TheFs.SetSessionPath(systestname);
 
   734 	test_KErrNone(r);
 
   736 	test(r==KErrNone);
 
   735 	
   737 	
   736 //Test RRawDisk class
 
   738 //Test RRawDisk class
 
   737 	r=rawdisk.Open(TheFs,gTheDriveNum);
 
   739 	r=rawdisk.Open(TheFs,gTheDriveNum);
 
   738 	test_Value(r, r == KErrPermissionDenied);
 
   740 	test(r==KErrPermissionDenied);
 
   739 	rawdisk.Close();
 
   741 	rawdisk.Close();
 
   740 
   742 
   741 	RDirtest();
 
   743 	RDirtest();
 
   742 
   744 
   743 #ifdef __WINS__
 
   745 #ifdef __WINS__
 
   744 	if (User::UpperCase(driveBuf[0]) != 'C')
 
   746 	if (User::UpperCase(driveBuf[0]) != 'C')
 
   745 #endif
 
   747 #endif
 
   746 		{
 
   748 		{
 
   747 		//Test RFormat class
 
   749 		//Test RFormat class
 
   748 		r=format.Open(TheFs,driveBuf,EHighDensity,count);
 
   750 		r=format.Open(TheFs,driveBuf,EHighDensity,count);
 
   749 		test_KErrNone(r);
 
   751 		test(r==KErrNone);
 
   750 		while(count)	
   752 		while(count)	
   751 			{
 
   753 			{
 
   752 			TInt r=format.Next(count);
 
   754 			TInt r=format.Next(count);
 
   753 			test_KErrNone(r);
 
   755 			test(r==KErrNone);
 
   754 			}
 
   756 			}
 
   755 		format.Close();
 
   757 		format.Close();
 
   756 		}
 
   758 		}
 
   757 
   759 
   758 	driveBuf[0]=(TText)gDriveToTest;
 
   760 	driveBuf[0]=(TText)gDriveToTest;
 
   759 	r=TheFs.ScanDrive(driveBuf);
 
   761 	r=TheFs.ScanDrive(driveBuf);
 
   760 	test_Value(r, r == KErrNone || r==KErrNotSupported || r == KErrInUse);
 
   762 	test(r==KErrNone || r==KErrNotSupported || KErrInUse);
 
   761 	r=TheFs.CheckDisk(driveBuf);
 
   763 	r=TheFs.CheckDisk(driveBuf);
 
   762 	test_Value(r, r == KErrNone || r==KErrNotSupported || r == KErrInUse);
 
   764 	test(r==KErrNone || r==KErrNotSupported || KErrInUse);
 
   763 	}
 
   765 	}
 
   764 
   766 
   765 LOCAL_C void TestCaps()
 
   767 LOCAL_C void TestCaps()
 
   766 //
 
   768 //
 
   767 //	test format etc that require certain capabilities
 
   769 //	test format etc that require certain capabilities
 
   775 	r=RProcess().HasCapability(ECapabilityDiskAdmin, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg));
 
   777 	r=RProcess().HasCapability(ECapabilityDiskAdmin, __PLATSEC_DIAGNOSTIC_STRING(myDiagMsg));
 
   776 	test(r);
 
   778 	test(r);
 
   777 
   779 
   778 	driveBuf[0]=(TText)gDriveToTest;
 
   780 	driveBuf[0]=(TText)gDriveToTest;
 
   779 	r=TheFs.SessionPath(temp);
 
   781 	r=TheFs.SessionPath(temp);
 
   780 	test_KErrNone(r);
 
   782 	test(r==KErrNone);
 
   781 
   783 
   782 	test.Printf(_L("Session path: %S"),&temp);
 
   784 	test.Printf(_L("Session path: %S"),&temp);
 
   783 
   785 
   784 	r=TheFs.CreatePrivatePath(gTheDriveNum);
 
   786 	r=TheFs.CreatePrivatePath(gTheDriveNum);
 
   785 	test_Value(r, r == KErrNone || r== KErrAlreadyExists);
 
   787 	test(r==KErrNone || r== KErrAlreadyExists);
 
   786 
   788 
   787 	TBuf<18> tempPri;
 
   789 	TBuf<18> tempPri;
 
   788 	r=TheFs.PrivatePath(tempPri);
 
   790 	r=TheFs.PrivatePath(tempPri);
 
   789 	test_KErrNone(r);
 
   791 	test(r==KErrNone);
 
   790 	theprivatepath = _L("?:");
 
   792 	theprivatepath = _L("?:");
 
   791 	theprivatepath.Append(tempPri);
 
   793 	theprivatepath.Append(tempPri);
 
   792 
   794 
   793 	TestDiskAdminAllfiles();
 
   795 	TestDiskAdminAllfiles();
 
   794 	
   796 	
   795 	TFileName thesessionpath;
 
   797 	TFileName thesessionpath;
 
   796 	r=TheFs.SetSessionToPrivate(gTheDriveNum);
 
   798 	r=TheFs.SetSessionToPrivate(gTheDriveNum);
 
   797 	test_KErrNone(r);
 
   799 	test(r==KErrNone);
 
   798 	r=TheFs.SessionPath(thesessionpath);
 
   800 	r=TheFs.SessionPath(thesessionpath);
 
   799 	test_KErrNone(r);
 
   801 	test(r==KErrNone);
 
   800 	test(thesessionpath == theprivatepath);
 
   802 	test(thesessionpath == theprivatepath);
 
   801 	}
 
   803 	}
 
   802 
   804 
   803 
   805 
   804 LOCAL_C void CleanupL()
 
   806 LOCAL_C void CleanupL()
 
   807 //
 
   809 //
 
   808 	{
 
   810 	{
 
   809 	test.Next(_L("Delete test directory"));
 
   811 	test.Next(_L("Delete test directory"));
 
   810 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   812 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   811 	TInt r=fMan->RmDir(gSessionPath);
 
   813 	TInt r=fMan->RmDir(gSessionPath);
 
   812 	test_Value(r, r == KErrNone || r == KErrPathNotFound);
 
   814 	test(r==KErrNone || KErrPathNotFound);
 
   813 	delete fMan;
 
   815 	delete fMan;
 
   814 	}
 
   816 	}
 
   815 
   817 
   816 GLDEF_C void CallTestsL(/*TChar aDriveLetter*/)
 
   818 GLDEF_C void CallTestsL(/*TChar aDriveLetter*/)
 
   817 //
 
   819 //
 
   831 	TBuf<30> sesspath;
 
   833 	TBuf<30> sesspath;
 
   832 	sesspath=_L("?:\\");
 
   834 	sesspath=_L("?:\\");
 
   833 	sesspath[0] = (TText)gDriveToTest;
 
   835 	sesspath[0] = (TText)gDriveToTest;
 
   834 
   836 
   835 	TInt r= TheFs.SetSessionPath(sesspath);
 
   837 	TInt r= TheFs.SetSessionPath(sesspath);
 
   836 	test_KErrNone(r);
 
   838 	test(r==KErrNone);
 
   837 
   839 
   838 	TBuf<2> cmd;
 
   840 	TBuf<2> cmd;
 
   839 	cmd.SetLength(1);
 
   841 	cmd.SetLength(1);
 
   840 	cmd[0] = (TText)gDriveToTest;
 
   842 	cmd[0] = (TText)gDriveToTest;
 
   841 	RProcess tp;
 
   843 	RProcess tp;
 
   842 	r=tp.Create(_L("clean_prepdc.exe"),sesspath);
 
   844 	r=tp.Create(_L("clean_prepdc.exe"),sesspath);
 
   843 	test_KErrNone(r);
 
   845 	test(r==KErrNone);
 
   844 	{
 
   846 	{
 
   845 	TRequestStatus ps;
 
   847 	TRequestStatus ps;
 
   846 	tp.Logon(ps);
 
   848 	tp.Logon(ps);
 
   847 	tp.Resume();
 
   849 	tp.Resume();
 
   848 	tp.Close();
 
   850 	tp.Close();
 
   852 	//check double mode ie that Defpath still works	
   854 	//check double mode ie that Defpath still works	
   853 	RFs fs1;
 
   855 	RFs fs1;
 
   854 	RFs fs2;
 
   856 	RFs fs2;
 
   855 	
   857 	
   856 	r=fs1.Connect();
 
   858 	r=fs1.Connect();
 
   857 	test_KErrNone(r);
 
   859 	test(r==KErrNone);
 
   858 	r=fs1.SessionPath(sesspath);
 
   860 	r=fs1.SessionPath(sesspath);
 
   859 	test_KErrNone(r);
 
   861 	test(r==KErrNone);
 
   860 	test.Printf(_L("session1 Path=%S"),&sesspath);
 
   862 	test.Printf(_L("session1 Path=%S"),&sesspath);
 
   861 
   863 
   862 	TBuf<30> privatepath;
 
   864 	TBuf<30> privatepath;
 
   863 	r=fs1.SetSessionToPrivate(gTheDriveNum);
 
   865 	r=fs1.SetSessionToPrivate(gTheDriveNum);
 
   864 	test_KErrNone(r);
 
   866 	test(r==KErrNone);
 
   865 	r=fs1.PrivatePath(privatepath);
 
   867 	r=fs1.PrivatePath(privatepath);
 
   866 	test_KErrNone(r);
 
   868 	test(r==KErrNone);
 
   867 	r=privatepath.Compare(KExpectedPrivatePath());
 
   869 	r=privatepath.Compare(KExpectedPrivatePath());
 
   868 	test_Value(r, r == 0);
 
   870 	test(r==0);
 
   869 	r=fs1.SessionPath(sesspath);
 
   871 	r=fs1.SessionPath(sesspath);
 
   870 	test_KErrNone(r);
 
   872 	test(r==KErrNone);
 
   871 	r=privatepath.Compare(sesspath.Mid(KPathPosition));
 
   873 	r=privatepath.Compare(sesspath.Mid(KPathPosition));
 
   872 	test_Value(r, r == 0);
 
   874 	test(r==0);
 
   873 	r=fs1.CreatePrivatePath(gTheDriveNum);
 
   875 	r=fs1.CreatePrivatePath(gTheDriveNum);
 
   874 	test_KErrNone(r);
 
   876 	test(r==KErrNone);
 
   875 	fs1.Close();
 
   877 	fs1.Close();
 
   876 
   878 
   877 	r=fs2.Connect();
 
   879 	r=fs2.Connect();
 
   878 	test_KErrNone(r);
 
   880 	test(r==KErrNone);
 
   879 	r=fs2.SessionPath(sesspath);
 
   881 	r=fs2.SessionPath(sesspath);
 
   880 	test_KErrNone(r);
 
   882 	test(r==KErrNone);
 
   881 	test.Printf(_L("session2 Path=%S"),&sesspath);
 
   883 	test.Printf(_L("session2 Path=%S"),&sesspath);
 
   882 	fs2.Close();
 
   884 	fs2.Close();
 
   883 
   885 
   884 	TestCaps();
 
   886 	TestCaps();
 
   885 
   887
MCL/sf/os/kernelhwsrv