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