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_misc.cpp
branchRCL_3
changeset 294 039a3e647356
parent 268 345b1ca54e88
equal deleted inserted replaced
268:345b1ca54e88 294:039a3e647356 
    13 // Description:
 
    13 // Description:
 
    14 // f32test\server\t_misc.cpp
 
    14 // f32test\server\t_misc.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 "t_server.h"
 
    20 #include "t_server.h"
 
    22 
       
    23 #include "f32_test_utils.h"
 
       
    24 using namespace F32_Test_Utils;
 
       
    25 
       
    26 
       
    27 // If there is an NFE media driver present, then because of the way EDeleteNotify requests work,
 
       
    28 // the data retrieved from a deleted file will not be a buffer full of zero's, but instead a buffer
 
       
    29 // full of decrypted zero's
 
       
    30 #define __NFE_MEDIA_DRIVER_PRESENT__
 
       
    31 
    21 
    32 #ifdef __VC32__
 
    22 #ifdef __VC32__
 
    33     // Solve compilation problem caused by non-English locale
 
    23     // Solve compilation problem caused by non-English locale
 
    34     #pragma setlocale("english")
 
    24     #pragma setlocale("english")
 
    35 #endif
 
    25 #endif
 
    36 
    26 
    37 RTest test(_L("T_MISC"));
 
    27 GLDEF_D RTest test(_L("T_MISC"));
 
    38 
    28 
    39 
    29 LOCAL_C void Test1()
 
    40 TInt gDriveNum = -1;
 
       
    41 const TUint KBufLength = 0x100;
 
       
    42 
       
    43 static void Test1()
 
       
    44 //
 
    30 //
 
    45 // Open, write to and read from a file
 
    31 // Open, write to and read from a file
 
    46 //
 
    32 //
 
    47 	{
 
    33 	{
 
    48 
    34 
    49 	test.Next(_L("Open, write to and read from a file"));
 
    35 	test.Next(_L("Open, write to and read from a file"));
 
    50 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    36 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    51 	test_KErrNone(r);
 
    37 	test(r==KErrNone);
 
    52 	RFile file;
 
    38 	RFile file;
 
    53 	r=file.Create(TheFs,_L("Hello.Wld"),EFileWrite);
 
    39 	r=file.Create(TheFs,_L("Hello.Wld"),EFileWrite);
 
    54 	test_KErrNone(r);
 
    40 	test(r==KErrNone);
 
    55 	r=file.Write(_L8("Hello World"),11);
 
    41 	r=file.Write(_L8("Hello World"),11);
 
    56 	test_KErrNone(r);
 
    42 	test(r==KErrNone);
 
    57 	file.Close();
 
    43 	file.Close();
 
    58 
    44 
    59 	r=file.Open(TheFs,_L("Hello.Wld"),EFileRead);
 
    45 	r=file.Open(TheFs,_L("Hello.Wld"),EFileRead);
 
    60 	test_KErrNone(r);
 
    46 	test(r==KErrNone);
 
    61 	TBuf8<256> buf;
 
    47 	TBuf8<256> buf;
 
    62 	r=file.Read(buf);
 
    48 	r=file.Read(buf);
 
    63 	test_KErrNone(r);
 
    49 	test(r==KErrNone);
 
    64 	test(buf==_L8("Hello World"));
 
    50 	test(buf==_L8("Hello World"));
 
    65 	file.Close();
 
    51 	file.Close();
 
    66 	}
 
    52 	}
 
    67 
    53 
    68 static void Test2()
 
    54 LOCAL_C void Test2()
 
    69 //
 
    55 //
 
    70 // Open and read from a file
 
    56 // Open and read from a file
 
    71 //
 
    57 //
 
    72 	{
 
    58 	{
 
    73 
    59 
    74 	test.Next(_L("Open and read from a file"));
 
    60 	test.Next(_L("Open and read from a file"));
 
    75 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    61 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    76 	test_KErrNone(r);
 
    62 	test(r==KErrNone);
 
    77 	RFile file;
 
    63 	RFile file;
 
    78 	r=file.Open(TheFs,_L("Hello.Wld"),EFileRead);
 
    64 	r=file.Open(TheFs,_L("Hello.Wld"),EFileRead);
 
    79 	test_KErrNone(r);
 
    65 	test(r==KErrNone);
 
    80 	TBuf8<256> buf;
 
    66 	TBuf8<256> buf;
 
    81 	r=file.Read(buf);
 
    67 	r=file.Read(buf);
 
    82 	test_KErrNone(r);
 
    68 	test(r==KErrNone);
 
    83 	test(buf==_L8("Hello World"));
 
    69 	test(buf==_L8("Hello World"));
 
    84 	file.Close();
 
    70 	file.Close();
 
    85 	r=TheFs.Delete(_L("HELLO.WLD"));
 
    71 	r=TheFs.Delete(_L("HELLO.WLD"));
 
    86 	test_KErrNone(r);
 
    72 	test(r==KErrNone);
 
    87 	}
 
    73 	}
 
    88 
    74 
    89 static void Test3()
 
    75 LOCAL_C void Test3()
 
    90 //
 
    76 //
 
    91 // Create nested directories
 
    77 // Create nested directories
 
    92 //
 
    78 //
 
    93 	{
 
    79 	{
 
    94 
    80 
    95 	test.Next(_L("Create nested directories"));
 
    81 	test.Next(_L("Create nested directories"));
 
    96 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    82 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    97 	test_KErrNone(r);
 
    83 	test(r==KErrNone);
 
    98 	TheFs.ResourceCountMarkStart();
 
    84 	TheFs.ResourceCountMarkStart();
 
    99 //
 
    85 //
 
   100 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\A.B"));
 
    86 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\A.B"));
 
   101 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
    87 	test(r==KErrNone || r==KErrAlreadyExists);
 
   102 	r=TheFs.MkDir(_L("\\F32-TST\\RIGHT\\"));
 
    88 	r=TheFs.MkDir(_L("\\F32-TST\\RIGHT\\"));
 
   103 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
    89 	test(r==KErrNone || r==KErrAlreadyExists);
 
   104 //
 
    90 //
 
   105 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\ONE\\"));
 
    91 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\ONE\\"));
 
   106 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
    92 	test(r==KErrNone || r==KErrAlreadyExists);
 
   107 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\TWO\\"));
 
    93 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\TWO\\"));
 
   108 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
    94 	test(r==KErrNone || r==KErrAlreadyExists);
 
   109 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\THREE\\"));
 
    95 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\THREE\\"));
 
   110 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
    96 	test(r==KErrNone || r==KErrAlreadyExists);
 
   111 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\TWO\\BOTTOM\\"));
 
    97 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\TWO\\BOTTOM\\"));
 
   112 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
    98 	test(r==KErrNone || r==KErrAlreadyExists);
 
   113 //
 
    99 //
 
   114 	r=TheFs.MkDirAll(_L("\\F32-TST\\RIGHT\\TOP\\MID\\BOT\\"));
 
   100 	r=TheFs.MkDirAll(_L("\\F32-TST\\RIGHT\\TOP\\MID\\BOT\\"));
 
   115 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   101 	test(r==KErrNone || r==KErrAlreadyExists);
 
   116 	}
 
   102 	}
 
   117 
   103 
   118 static void Test4()
 
   104 LOCAL_C void Test4()
 
   119 //
 
   105 //
 
   120 // Test returned error values
 
   106 // Test returned error values
 
   121 //
 
   107 //
 
   122 	{
 
   108 	{
 
   123 
   109 
   124 	test.Next(_L("Test returned error values"));
 
   110 	test.Next(_L("Test returned error values"));
 
   125 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
   111 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
   126 	test_KErrNone(r);
 
   112 	test(r==KErrNone);
 
   127 	TheFs.ResourceCountMarkStart();
 
   113 	TheFs.ResourceCountMarkStart();
 
   128 //
 
   114 //
 
   129 	r=TheFs.MkDir(_L("\\"));
 
   115 	r=TheFs.MkDir(_L("\\"));
 
   130 	test_Value(r, r == KErrAlreadyExists);
 
   116 	test(r==KErrAlreadyExists);
 
   131 	r=TheFs.MkDir(_L("\\LEFT"));
 
   117 	r=TheFs.MkDir(_L("\\LEFT"));
 
   132 	test_Value(r, r == KErrAlreadyExists);
 
   118 	test(r==KErrAlreadyExists);
 
   133 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\"));
 
   119 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\"));
 
   134 	test_Value(r, r == KErrAlreadyExists);
 
   120 	test(r==KErrAlreadyExists);
 
   135 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\..\\NEWDIR\\"));
 
   121 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\..\\NEWDIR\\"));
 
   136 	test_Value(r, r == KErrBadName);
 
   122 	test(r==KErrBadName);
 
   137 	r=TheFs.MkDir(_L("\\F32-TST\\NEWDIR\\SUBDIR\\"));
 
   123 	r=TheFs.MkDir(_L("\\F32-TST\\NEWDIR\\SUBDIR\\"));
 
   138 	test_Value(r, r == KErrPathNotFound);
 
   124 	test(r==KErrPathNotFound);
 
   139 //
 
   125 //
 
   140 	r=TheFs.RmDir(_L("\\"));
 
   126 	r=TheFs.RmDir(_L("\\"));
 
   141 	test_Value(r, r == KErrInUse);
 
   127 	test(r==KErrInUse);
 
   142 	r=TheFs.RmDir(_L("\\PROG"));
 
   128 	r=TheFs.RmDir(_L("\\PROG"));
 
   143 	test_Value(r, r == KErrInUse);
 
   129 	test(r==KErrInUse);
 
   144 	r=TheFs.RmDir(_L("\\F32-TST\\"));
 
   130 	r=TheFs.RmDir(_L("\\F32-TST\\"));
 
   145 	test_Value(r, r == KErrInUse);
 
   131 	test(r==KErrInUse);
 
   146 
   132 
   147 
   133 
   148 	RDir dir;
 
   134 	RDir dir;
 
   149 	r=dir.Open(TheFs,_L("V:\\asdf"),KEntryAttNormal);
 
   135 	r=dir.Open(TheFs,_L("V:\\asdf"),KEntryAttNormal);
 
   150 	test_Value(r, r == KErrNone || r==KErrNotReady || r==KErrNotFound);
 
   136 	test(r==KErrNone || r==KErrNotReady || r==KErrNotFound);
 
   151 	if (r==KErrNone)
 
   137 	if (r==KErrNone)
 
   152 		dir.Close();
 
   138 		dir.Close();
 
   153 	r=dir.Open(TheFs,_L("L:\\asdf"),KEntryAttNormal);
 
   139 	r=dir.Open(TheFs,_L("L:\\asdf"),KEntryAttNormal);
 
   154 	test_Value(r, r == KErrNone || r==KErrNotReady || r==KErrNotFound);
 
   140 	test(r==KErrNone || r==KErrNotReady || r==KErrNotFound);
 
   155 	dir.Close();
 
   141 	dir.Close();
 
   156 //
 
   142 //
 
   157 	TEntry entry;
 
   143 	TEntry entry;
 
   158 	r=TheFs.Entry(_L("z:\\NOTEXiSTS\\file.txt"),entry);
 
   144 	r=TheFs.Entry(_L("z:\\NOTEXiSTS\\file.txt"),entry);
 
   159 	test_Value(r, r == KErrPathNotFound);
 
   145 	test(r==KErrPathNotFound);
 
   160 	r=TheFs.Entry(_L("z:\\NOTEXiSTS\\"),entry);
 
   146 	r=TheFs.Entry(_L("z:\\NOTEXiSTS\\"),entry);
 
   161 	test_Value(r, r == KErrNotFound);
 
   147 	test(r==KErrNotFound);
 
   162 	r=TheFs.Entry(_L("z:\\SYSTEM\\"),entry);
 
   148 	r=TheFs.Entry(_L("z:\\SYSTEM\\"),entry);
 
   163 	test_KErrNone(r);
 
   149 	test(r==KErrNone);
 
   164 	r=TheFs.Entry(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("z:\\SYS\\BIN\\ESHELL.EXE"):_L("z:\\SYSTEM\\BIN\\ESHELL.EXE"),entry);
 
   150 	r=TheFs.Entry(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("z:\\SYS\\BIN\\ESHELL.EXE"):_L("z:\\SYSTEM\\BIN\\ESHELL.EXE"),entry);
 
   165 	test_KErrNone(r);
 
   151 	test(r==KErrNone);
 
   166 
   152 
   167 	r=dir.Open(TheFs,_L("\\*"),NULL);
 
   153 	r=dir.Open(TheFs,_L("\\*"),NULL);
 
   168 	test_KErrNone(r);
 
   154 	test(r==KErrNone);
 
   169 	TEntry dirEntry;
 
   155 	TEntry dirEntry;
 
   170 	r=dir.Read(dirEntry);
 
   156 	r=dir.Read(dirEntry);
 
   171 	test_Value(r, r == KErrNone || r==KErrEof);
 
   157 	test(r==KErrNone || r==KErrEof);
 
   172 	if (r==KErrNone)
 
   158 	if (r==KErrNone)
 
   173 		test.Printf(_L("%S\n"),&dirEntry.iName);
 
   159 		test.Printf(_L("%S\n"),&dirEntry.iName);
 
   174 	dir.Close();
 
   160 	dir.Close();
 
   175 
   161 
   176 	r=dir.Open(TheFs,_L("A:\\*"),NULL);
 
   162 	r=dir.Open(TheFs,_L("A:\\*"),NULL);
 
   177 	test_Value(r, r == KErrNotReady || r==KErrNone);
 
   163 	test(r==KErrNotReady || r==KErrNone);
 
   178 	dir.Close();
 
   164 	dir.Close();
 
   179 	}
 
   165 	}
 
   180 
   166 
   181 static void Test5()
 
   167 LOCAL_C void Test5()
 
   182 //
 
   168 //
 
   183 // Read files directly from the rom
 
   169 // Read files directly from the rom
 
   184 //
 
   170 //
 
   185 
   171 
   186 	{
 
   172 	{
 
   193 
   179 
   194 	if ( TheFs.IsFileInRom(KTFileCpp) != NULL && TheFs.IsFileInRom(KTFsrvCpp) != NULL )
 
   180 	if ( TheFs.IsFileInRom(KTFileCpp) != NULL && TheFs.IsFileInRom(KTFsrvCpp) != NULL )
 
   195 		{
 
   181 		{
 
   196 		RFile f;
 
   182 		RFile f;
 
   197 		r=f.Open(TheFs,KTFileCpp,EFileRead);
 
   183 		r=f.Open(TheFs,KTFileCpp,EFileRead);
 
   198 		test_KErrNone(r);
 
   184 		test(r==KErrNone);
 
   199 		r=f.Seek(ESeekAddress,pos);
 
   185 		r=f.Seek(ESeekAddress,pos);
 
   200 		TText8* ptrPos=*(TText8**)&pos;
 
   186 		TText8* ptrPos=*(TText8**)&pos;
 
   201 		test_KErrNone(r);
 
   187 		test(r==KErrNone);
 
   202 		TBuf8<1024> readBuf;
 
   188 		TBuf8<1024> readBuf;
 
   203 		r=f.Read(readBuf);
 
   189 		r=f.Read(readBuf);
 
   204 		test_KErrNone(r);
 
   190 		test(r==KErrNone);
 
   205 		test(readBuf.Length()==readBuf.MaxLength());
 
   191 		test(readBuf.Length()==readBuf.MaxLength());
 
   206 		TPtrC8 memBuf(ptrPos,readBuf.Length());
 
   192 		TPtrC8 memBuf(ptrPos,readBuf.Length());
 
   207 		test(memBuf==readBuf);
 
   193 		test(memBuf==readBuf);
 
   208 
   194 
   209 		ptrPos+=9913;
 
   195 		ptrPos+=9913;
 
   210 		pos=9913;
 
   196 		pos=9913;
 
   211 		r=f.Seek(ESeekStart,pos);
 
   197 		r=f.Seek(ESeekStart,pos);
 
   212 		test_KErrNone(r);
 
   198 		test(r==KErrNone);
 
   213 		readBuf.SetLength(0);
 
   199 		readBuf.SetLength(0);
 
   214 		r=f.Read(readBuf);
 
   200 		r=f.Read(readBuf);
 
   215 		test_KErrNone(r);
 
   201 		test(r==KErrNone);
 
   216 		test(readBuf.Length()==readBuf.MaxLength());
 
   202 		test(readBuf.Length()==readBuf.MaxLength());
 
   217 		memBuf.Set(ptrPos,readBuf.Length());
 
   203 		memBuf.Set(ptrPos,readBuf.Length());
 
   218 		test(memBuf==readBuf);
 
   204 		test(memBuf==readBuf);
 
   219 
   205 
   220 		RFile f2;
 
   206 		RFile f2;
 
   221 		pos=10;
 
   207 		pos=10;
 
   222 		r=f2.Open(TheFs,KTFsrvCpp,EFileRead);
 
   208 		r=f2.Open(TheFs,KTFsrvCpp,EFileRead);
 
   223 
   209 
   224 		test_KErrNone(r);
 
   210 		test(r==KErrNone);
 
   225 		r=f2.Seek(ESeekAddress,pos);
 
   211 		r=f2.Seek(ESeekAddress,pos);
 
   226 		ptrPos=*(TText8**)&pos;
 
   212 		ptrPos=*(TText8**)&pos;
 
   227 		test_KErrNone(r);
 
   213 		test(r==KErrNone);
 
   228 		readBuf.SetLength(0);
 
   214 		readBuf.SetLength(0);
 
   229 		pos=10;
 
   215 		pos=10;
 
   230 		r=f2.Seek(ESeekStart,pos);
 
   216 		r=f2.Seek(ESeekStart,pos);
 
   231 		test_KErrNone(r);
 
   217 		test(r==KErrNone);
 
   232 		r=f2.Read(readBuf);
 
   218 		r=f2.Read(readBuf);
 
   233 		test_KErrNone(r);
 
   219 		test(r==KErrNone);
 
   234 		test(readBuf.Length()==readBuf.MaxLength());
 
   220 		test(readBuf.Length()==readBuf.MaxLength());
 
   235 		memBuf.Set(ptrPos,readBuf.Length());
 
   221 		memBuf.Set(ptrPos,readBuf.Length());
 
   236 		test(memBuf==readBuf);
 
   222 		test(memBuf==readBuf);
 
   237 
   223 
   238 		ptrPos+=2445;
 
   224 		ptrPos+=2445;
 
   239 		pos=10+2445;
 
   225 		pos=10+2445;
 
   240 		r=f2.Seek(ESeekStart,pos);
 
   226 		r=f2.Seek(ESeekStart,pos);
 
   241 		test_KErrNone(r);
 
   227 		test(r==KErrNone);
 
   242 		readBuf.SetLength(0);
 
   228 		readBuf.SetLength(0);
 
   243 		r=f2.Read(readBuf);
 
   229 		r=f2.Read(readBuf);
 
   244 		test_KErrNone(r);
 
   230 		test(r==KErrNone);
 
   245 		test(readBuf.Length()==readBuf.MaxLength());
 
   231 		test(readBuf.Length()==readBuf.MaxLength());
 
   246 		memBuf.Set(ptrPos,readBuf.Length());
 
   232 		memBuf.Set(ptrPos,readBuf.Length());
 
   247 		test(memBuf==readBuf);
 
   233 		test(memBuf==readBuf);
 
   248 
   234 
   249 		pos=0;
 
   235 		pos=0;
 
   250 		r=f.Seek(ESeekAddress,pos);
 
   236 		r=f.Seek(ESeekAddress,pos);
 
   251 		ptrPos=*(TText8**)&pos;
 
   237 		ptrPos=*(TText8**)&pos;
 
   252 		test_KErrNone(r);
 
   238 		test(r==KErrNone);
 
   253 		readBuf.SetLength(0);
 
   239 		readBuf.SetLength(0);
 
   254 		pos=0;
 
   240 		pos=0;
 
   255 		r=f.Seek(ESeekStart,pos);
 
   241 		r=f.Seek(ESeekStart,pos);
 
   256 		test_KErrNone(r);
 
   242 		test(r==KErrNone);
 
   257 		r=f.Read(readBuf);
 
   243 		r=f.Read(readBuf);
 
   258 		test_KErrNone(r);
 
   244 		test(r==KErrNone);
 
   259 		test(readBuf.Length()==readBuf.MaxLength());
 
   245 		test(readBuf.Length()==readBuf.MaxLength());
 
   260 		memBuf.Set(ptrPos,readBuf.Length());
 
   246 		memBuf.Set(ptrPos,readBuf.Length());
 
   261 		test(memBuf==readBuf);
 
   247 		test(memBuf==readBuf);
 
   262 
   248 
   263 		ptrPos+=5245;
 
   249 		ptrPos+=5245;
 
   264 		pos=5245;
 
   250 		pos=5245;
 
   265 		r=f.Seek(ESeekStart,pos);
 
   251 		r=f.Seek(ESeekStart,pos);
 
   266 		test_KErrNone(r);
 
   252 		test(r==KErrNone);
 
   267 		readBuf.SetLength(0);
 
   253 		readBuf.SetLength(0);
 
   268 		r=f.Read(readBuf);
 
   254 		r=f.Read(readBuf);
 
   269 		test_KErrNone(r);
 
   255 		test(r==KErrNone);
 
   270 		test(readBuf.Length()==readBuf.MaxLength());
 
   256 		test(readBuf.Length()==readBuf.MaxLength());
 
   271 		memBuf.Set(ptrPos,readBuf.Length());
 
   257 		memBuf.Set(ptrPos,readBuf.Length());
 
   272 		test(memBuf==readBuf);
 
   258 		test(memBuf==readBuf);
 
   273 
   259 
   274 		f.Close();
 
   260 		f.Close();
 
   275 		f2.Close();
 
   261 		f2.Close();
 
   276 		}
 
   262 		}
 
   277 	}
 
   263 	}
 
   278 
   264 
   279 static void Test6()
 
   265 LOCAL_C void Test6()
 
   280 //
 
   266 //
 
   281 // Test rom return values
 
   267 // Test rom return values
 
   282 //
 
   268 //
 
   283 	{
 
   269 	{
 
   284 	test.Next(_L("Test rom return values"));
 
   270 	test.Next(_L("Test rom return values"));
 
   285 
   271 
   286 	RFile f;
 
   272 	RFile f;
 
   287 	TInt r=f.Replace(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead);
 
   273 	TInt r=f.Replace(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead);
 
   288 	test_Value(r, r == KErrAccessDenied);
 
   274 	test(r==KErrAccessDenied);
 
   289 	r=f.Create(TheFs,_L("Z:\\Test\\newT_Fsrv.Cpp"),EFileRead);
 
   275 	r=f.Create(TheFs,_L("Z:\\Test\\newT_Fsrv.Cpp"),EFileRead);
 
   290 	test_Value(r, r == KErrAccessDenied);
 
   276 	test(r==KErrAccessDenied);
 
   291 	r=f.Open(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead);
 
   277 	r=f.Open(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead);
 
   292 	test_KErrNone(r);
 
   278 	test(r==KErrNone);
 
   293 	f.Close();
 
   279 	f.Close();
 
   294 	r=f.Open(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead|EFileWrite);
 
   280 	r=f.Open(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead|EFileWrite);
 
   295 	test_Value(r, r == KErrAccessDenied);
 
   281 	test(r==KErrAccessDenied);
 
   296 	}
 
   282 	}
 
   297 
   283 
   298 static void Test7()
 
   284 LOCAL_C void Test7()
 
   299 //
 
   285 //
 
   300 // Test cache
 
   286 // Test cache
 
   301 //
 
   287 //
 
   302 	{
 
   288 	{
 
   303 
   289 
   307 	TBuf<32> file1=_L("\\TMISC\\CACHE.FILE");
 
   293 	TBuf<32> file1=_L("\\TMISC\\CACHE.FILE");
 
   308 	MakeFile(file1,uid1,contents1);
 
   294 	MakeFile(file1,uid1,contents1);
 
   309 
   295 
   310 	TEntry entry;
 
   296 	TEntry entry;
 
   311 	TInt r=TheFs.Entry(file1,entry);
 
   297 	TInt r=TheFs.Entry(file1,entry);
 
   312 	test_KErrNone(r);
 
   298 	test(r==KErrNone);
 
   313 	test(entry.iType==uid1);
 
   299 	test(entry.iType==uid1);
 
   314 
   300 
   315 	TUidType uid2(TUid::Uid(4),TUid::Uid(5),TUid::Uid(6));
 
   301 	TUidType uid2(TUid::Uid(4),TUid::Uid(5),TUid::Uid(6));
 
   316 	TCheckedUid checkedUid(uid2);
 
   302 	TCheckedUid checkedUid(uid2);
 
   317 	TPtrC8 uidData((TUint8*)&checkedUid,sizeof(TCheckedUid));
 
   303 	TPtrC8 uidData((TUint8*)&checkedUid,sizeof(TCheckedUid));
 
   318 	RFile f;
 
   304 	RFile f;
 
   319 	r=f.Open(TheFs,file1,EFileRead|EFileWrite);
 
   305 	r=f.Open(TheFs,file1,EFileRead|EFileWrite);
 
   320 	test_KErrNone(r);
 
   306 	test(r==KErrNone);
 
   321 	r=f.Write(uidData);
 
   307 	r=f.Write(uidData);
 
   322 	test_KErrNone(r);
 
   308 	test(r==KErrNone);
 
   323 	r = f.Flush();
 
   309 	r = f.Flush();
 
   324 	test_KErrNone(r);
 
   310 	test(r==KErrNone);
 
   325 
   311 
   326 	r=TheFs.Entry(file1,entry);
 
   312 	r=TheFs.Entry(file1,entry);
 
   327 	test_KErrNone(r);
 
   313 	test(r==KErrNone);
 
   328 	test(entry.iType==uid2);
 
   314 	test(entry.iType==uid2);
 
   329 
   315 
   330 	f.Close();
 
   316 	f.Close();
 
   331 	r=TheFs.Entry(file1,entry);
 
   317 	r=TheFs.Entry(file1,entry);
 
   332 	test_KErrNone(r);
 
   318 	test(r==KErrNone);
 
   333 	test(entry.iType==uid2);
 
   319 	test(entry.iType==uid2);
 
   334 	}
 
   320 	}
 
   335 
   321 
   336 static void Test8()
 
   322 LOCAL_C void Test8()
 
   337 //
 
   323 //
 
   338 // Test IsValidName
 
   324 // Test IsValidName
 
   339 //
 
   325 //
 
   340 	{
 
   326 	{
 
   341 	test.Next(_L("Test RFs::IsValidName(TDesC)"));
 
   327 	test.Next(_L("Test RFs::IsValidName(TDesC)"));
 
   540                 }
 
   526                 }
 
   541             }
 
   527             }
 
   542         }
 
   528         }
 
   543 	}
 
   529 	}
 
   544 
   530 
   545 static void Test9()
 
   531 LOCAL_C void Test9()
 
   546 //
 
   532 //
 
   547 // Test IsFileInRom
 
   533 // Test IsFileInRom
 
   548 //
 
   534 //
 
   549 	{
 
   535 	{
 
   550 
   536 
   551 	test.Next(_L("Test RFs::IsFileInRom"));
 
   537 	test.Next(_L("Test RFs::IsFileInRom"));
 
   552 
   538 
   553 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   539 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   554 	TInt r=fMan->Copy(_L("Z:\\TEST\\T_FILE.CPP"),_L("C:\\T_FILE.CPP"));
 
   540 	TInt r=fMan->Copy(_L("Z:\\TEST\\T_FILE.CPP"),_L("C:\\T_FILE.CPP"));
 
   555 	test_Value(r, r == KErrNone || r==KErrAccessDenied);
 
   541 	test(r==KErrNone || r==KErrAccessDenied);
 
   556 	delete fMan;
 
   542 	delete fMan;
 
   557 	TUint8* addr=TheFs.IsFileInRom(_L("C:\\ESHELL.EXE"));
 
   543 	TUint8* addr=TheFs.IsFileInRom(_L("C:\\ESHELL.EXE"));
 
   558 	test(addr==NULL);
 
   544 	test(addr==NULL);
 
   559 	addr=TheFs.IsFileInRom(_L("Z:\\TEST\\T_FILE.CPP"));
 
   545 	addr=TheFs.IsFileInRom(_L("Z:\\TEST\\T_FILE.CPP"));
 
   560 	if (addr!=NULL)
 
   546 	if (addr!=NULL)
 
   567 		{
 
   553 		{
 
   568 		test (addr==NULL);
 
   554 		test (addr==NULL);
 
   569 		}
 
   555 		}
 
   570 	}
 
   556 	}
 
   571 
   557 
   572 static void Test10()
 
   558 LOCAL_C void Test10()
 
   573 //
 
   559 //
 
   574 // Test drive names
 
   560 // Test drive names
 
   575 //
 
   561 //
 
   576 	{
 
   562 	{
 
   577 
   563 
   579 	TFileName driveName;
 
   565 	TFileName driveName;
 
   580 	TInt i;
 
   566 	TInt i;
 
   581 	for(i=0;i<KMaxDrives;i++)
 
   567 	for(i=0;i<KMaxDrives;i++)
 
   582 		{
 
   568 		{
 
   583 		TInt r=TheFs.GetDriveName(i,driveName);
 
   569 		TInt r=TheFs.GetDriveName(i,driveName);
 
   584 		test_KErrNone(r);
 
   570 		test(r==KErrNone);
 
   585 		if (driveName.Length())
 
   571 		if (driveName.Length())
 
   586 			test.Printf(_L("Default name of %c: == %S\n"),'A'+i,&driveName);
 
   572 			test.Printf(_L("Default name of %c: == %S\n"),'A'+i,&driveName);
 
   587 		}
 
   573 		}
 
   588 
   574 
   589 	TBuf<64> drive0=_L("Dilbert");
 
   575 	TBuf<64> drive0=_L("Dilbert");
 
   590 	TBuf<64> drive4=_L("Dogbert");
 
   576 	TBuf<64> drive4=_L("Dogbert");
 
   591 	TBuf<64> drive17=_L("Flibble");
 
   577 	TBuf<64> drive17=_L("Flibble");
 
   592 	TBuf<64> drive25=_L("RAMDRIVE");
 
   578 	TBuf<64> drive25=_L("RAMDRIVE");
 
   593 	TInt r=TheFs.SetDriveName(0,drive0);
 
   579 	TInt r=TheFs.SetDriveName(0,drive0);
 
   594 	test_KErrNone(r);
 
   580 	test(r==KErrNone);
 
   595 	r=TheFs.SetDriveName(4,drive4);
 
   581 	r=TheFs.SetDriveName(4,drive4);
 
   596 	test_KErrNone(r);
 
   582 	test(r==KErrNone);
 
   597 	r=TheFs.SetDriveName(17,drive17);
 
   583 	r=TheFs.SetDriveName(17,drive17);
 
   598 	test_KErrNone(r);
 
   584 	test(r==KErrNone);
 
   599 	r=TheFs.SetDriveName(25,drive25);
 
   585 	r=TheFs.SetDriveName(25,drive25);
 
   600 	test_KErrNone(r);
 
   586 	test(r==KErrNone);
 
   601 
   587 
   602 	r=TheFs.GetDriveName(0,driveName);
 
   588 	r=TheFs.GetDriveName(0,driveName);
 
   603 	test_KErrNone(r);
 
   589 	test(r==KErrNone);
 
   604 	test(driveName==drive0);
 
   590 	test(driveName==drive0);
 
   605 	r=TheFs.GetDriveName(4,driveName);
 
   591 	r=TheFs.GetDriveName(4,driveName);
 
   606 	test_KErrNone(r);
 
   592 	test(r==KErrNone);
 
   607 	test(driveName==drive4);
 
   593 	test(driveName==drive4);
 
   608 	r=TheFs.GetDriveName(17,driveName);
 
   594 	r=TheFs.GetDriveName(17,driveName);
 
   609 	test_KErrNone(r);
 
   595 	test(r==KErrNone);
 
   610 	test(driveName==drive17);
 
   596 	test(driveName==drive17);
 
   611 	r=TheFs.GetDriveName(25,driveName);
 
   597 	r=TheFs.GetDriveName(25,driveName);
 
   612 	test_KErrNone(r);
 
   598 	test(r==KErrNone);
 
   613 	test(driveName==drive25);
 
   599 	test(driveName==drive25);
 
   614 
   600 
   615 	drive0=_L("askdjflsdfourewoqiuroiuaksjdvx,cvsdhwjhjhalsjhfshfkjhslj");
 
   601 	drive0=_L("askdjflsdfourewoqiuroiuaksjdvx,cvsdhwjhjhalsjhfshfkjhslj");
 
   616 	r=TheFs.SetDriveName(0,drive0);
 
   602 	r=TheFs.SetDriveName(0,drive0);
 
   617 	test_KErrNone(r);
 
   603 	test(r==KErrNone);
 
   618 	r=TheFs.GetDriveName(0,driveName);
 
   604 	r=TheFs.GetDriveName(0,driveName);
 
   619 	test_KErrNone(r);
 
   605 	test(r==KErrNone);
 
   620 	test(driveName==drive0);
 
   606 	test(driveName==drive0);
 
   621 
   607 
   622 //	Test with illegal characters in drive name
 
   608 //	Test with illegal characters in drive name
 
   623 	drive0=_L("Dil>bert");
 
   609 	drive0=_L("Dil>bert");
 
   624 	drive4=_L("Dog?bert");
 
   610 	drive4=_L("Dog?bert");
 
   625 	drive17=_L("Fli*bble");
 
   611 	drive17=_L("Fli*bble");
 
   626 	drive25=_L("RAMD//RIVE");
 
   612 	drive25=_L("RAMD//RIVE");
 
   627 
   613 
   628 	r=TheFs.SetDriveName(0,drive0);
 
   614 	r=TheFs.SetDriveName(0,drive0);
 
   629 	test_Value(r, r == KErrBadName);
 
   615 	test(r==KErrBadName);
 
   630 	r=TheFs.SetDriveName(4,drive4);
 
   616 	r=TheFs.SetDriveName(4,drive4);
 
   631 	test_Value(r, r == KErrBadName);
 
   617 	test(r==KErrBadName);
 
   632 	r=TheFs.SetDriveName(17,drive17);
 
   618 	r=TheFs.SetDriveName(17,drive17);
 
   633 	test_Value(r, r == KErrBadName);
 
   619 	test(r==KErrBadName);
 
   634 	r=TheFs.SetDriveName(25,drive25);
 
   620 	r=TheFs.SetDriveName(25,drive25);
 
   635 	test_Value(r, r == KErrBadName);
 
   621 	test(r==KErrBadName);
 
   636 
   622 
   637 //	Test that it is OK to set the name to no characters
 
   623 //	Test that it is OK to set the name to no characters
 
   638 
   624 
   639 	drive0=_L("");
 
   625 	drive0=_L("");
 
   640 	drive4=_L("");
 
   626 	drive4=_L("");
 
   641 	drive17=_L("");
 
   627 	drive17=_L("");
 
   642 	drive25=_L("");
 
   628 	drive25=_L("");
 
   643 
   629 
   644 	r=TheFs.SetDriveName(0,drive0);
 
   630 	r=TheFs.SetDriveName(0,drive0);
 
   645 	test_KErrNone(r);
 
   631 	test(r==KErrNone);
 
   646 	r=TheFs.SetDriveName(4,drive4);
 
   632 	r=TheFs.SetDriveName(4,drive4);
 
   647 	test_KErrNone(r);
 
   633 	test(r==KErrNone);
 
   648 	r=TheFs.SetDriveName(17,drive17);
 
   634 	r=TheFs.SetDriveName(17,drive17);
 
   649 	test_KErrNone(r);
 
   635 	test(r==KErrNone);
 
   650 	r=TheFs.SetDriveName(25,drive25);
 
   636 	r=TheFs.SetDriveName(25,drive25);
 
   651 	test_KErrNone(r);
 
   637 	test(r==KErrNone);
 
   652 
   638 
   653 	r=TheFs.GetDriveName(0,driveName);
 
   639 	r=TheFs.GetDriveName(0,driveName);
 
   654 	test_KErrNone(r);
 
   640 	test(r==KErrNone);
 
   655 	test(driveName==drive0);
 
   641 	test(driveName==drive0);
 
   656 	r=TheFs.GetDriveName(4,driveName);
 
   642 	r=TheFs.GetDriveName(4,driveName);
 
   657 	test_KErrNone(r);
 
   643 	test(r==KErrNone);
 
   658 	test(driveName==drive4);
 
   644 	test(driveName==drive4);
 
   659 	r=TheFs.GetDriveName(17,driveName);
 
   645 	r=TheFs.GetDriveName(17,driveName);
 
   660 	test_KErrNone(r);
 
   646 	test(r==KErrNone);
 
   661 	test(driveName==drive17);
 
   647 	test(driveName==drive17);
 
   662 	r=TheFs.GetDriveName(25,driveName);
 
   648 	r=TheFs.GetDriveName(25,driveName);
 
   663 	test_KErrNone(r);
 
   649 	test(r==KErrNone);
 
   664 	test(driveName==drive25);
 
   650 	test(driveName==drive25);
 
   665 
   651 
   666 
   652 
   667 	}
 
   653 	}
 
   668 
   654 
   669 static void Test11()
 
   655 LOCAL_C void Test11()
 
   670 //
 
   656 //
 
   671 // Miscellaneous tests
 
   657 // Miscellaneous tests
 
   672 //
 
   658 //
 
   673 	{
 
   659 	{
 
   674 
   660 
   675 	test.Next(_L("Miscellaneous tests"));
 
   661 	test.Next(_L("Miscellaneous tests"));
 
   676 	TVolumeInfo vol;
 
   662 	TVolumeInfo vol;
 
   677 	TInt r=TheFs.Volume(vol);
 
   663 	TInt r=TheFs.Volume(vol);
 
   678 	test.Printf(_L("VolumeName = %S\n"),&vol.iName);
 
   664 	test.Printf(_L("VolumeName = %S\n"),&vol.iName);
 
   679 	test_KErrNone(r);
 
   665 	test(r==KErrNone);
 
   680 	r=TheFs.RmDir(_L("\\asdfasdf.\\"));
 
   666 	r=TheFs.RmDir(_L("\\asdfasdf.\\"));
 
   681 	test_Value(r, r == KErrBadName);
 
   667 	test(r==KErrBadName);
 
   682 	r=TheFs.MkDir(_L("\\asdfasdf.\\"));
 
   668 	r=TheFs.MkDir(_L("\\asdfasdf.\\"));
 
   683 	test_Value(r, r == KErrBadName);
 
   669 	test(r==KErrBadName);
 
   684 	}
 
   670 	}
 
   685 
   671 
   686 static void Test12()
 
   672 LOCAL_C void Test12()
 
   687 //
 
   673 //
 
   688 // Test SetNotifyUser and GetNotifyUser
 
   674 // Test SetNotifyUser and GetNotifyUser
 
   689 //
 
   675 //
 
   690 	{
 
   676 	{
 
   691 
   677 
   700 	TheFs.SetNotifyUser(notifyState);
 
   686 	TheFs.SetNotifyUser(notifyState);
 
   701 	notifyState=TheFs.GetNotifyUser();
 
   687 	notifyState=TheFs.GetNotifyUser();
 
   702 	test(notifyState);
 
   688 	test(notifyState);
 
   703 	}
 
   689 	}
 
   704 
   690 
   705 static void Test13()
 
   691 LOCAL_C void Test13()
 
   706 //
 
   692 //
 
   707 // Test return values from RFs::Volume on cf-cards
 
   693 // Test return values from RFs::Volume on cf-cards
 
   708 //
 
   694 //
 
   709 	{
 
   695 	{
 
   710 
   696 
   711 	test.Next(_L("Test RFs::Volume"));
 
   697 	test.Next(_L("Test RFs::Volume"));
 
   712 	TVolumeInfo vol;
 
   698 	TVolumeInfo vol;
 
   713 	TInt r=TheFs.Volume(vol,EDriveB);
 
   699 	TInt r=TheFs.Volume(vol,EDriveB);
 
   714 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   700 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   715 	test.Printf(_L("RFs::Volume EDriveB returned %d\n"),r);
 
   701 	test.Printf(_L("RFs::Volume EDriveB returned %d\n"),r);
 
   716 
   702 
   717 	r=TheFs.Volume(vol,EDriveC);
 
   703 	r=TheFs.Volume(vol,EDriveC);
 
   718 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   704 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   719 	test.Printf(_L("RFs::Volume EDriveC returned %d\n"),r);
 
   705 	test.Printf(_L("RFs::Volume EDriveC returned %d\n"),r);
 
   720 
   706 
   721 	r=TheFs.Volume(vol,EDriveD);
 
   707 	r=TheFs.Volume(vol,EDriveD);
 
   722 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   708 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   723 	test.Printf(_L("RFs::Volume EDriveD returned %d\n"),r);
 
   709 	test.Printf(_L("RFs::Volume EDriveD returned %d\n"),r);
 
   724 
   710 
   725 	r=TheFs.Volume(vol,EDriveE);
 
   711 	r=TheFs.Volume(vol,EDriveE);
 
   726 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   712 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   727 	test.Printf(_L("RFs::Volume EDriveE returned %d\n"),r);
 
   713 	test.Printf(_L("RFs::Volume EDriveE returned %d\n"),r);
 
   728 
   714 
   729 	r=TheFs.Volume(vol,EDriveF);
 
   715 	r=TheFs.Volume(vol,EDriveF);
 
   730 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   716 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   731 	test.Printf(_L("RFs::Volume EDriveF returned %d\n"),r);
 
   717 	test.Printf(_L("RFs::Volume EDriveF returned %d\n"),r);
 
   732 	}
 
   718 	}
 
   733 
   719 
   734 
   720 
   735 void    DoTest14(TInt aDrvNum);
 
   721 void    DoTest14(TInt aDrvNum);
 
   736 TInt    CreateStuffedFile(RFs& aFs, const TDesC& aFileName, TUint aFileSize);
 
   722 TInt    CreateStuffedFile(RFs& aFs, const TDesC& aFileName, TUint aFileSize);
 
       
   723 TInt    CreateEmptyFile(RFs& aFs, const TDesC& aFileName, TUint aFileSize);
 
   737 TBool   CheckFileContents(RFs& aFs, const TDesC& aFileName);
 
   724 TBool   CheckFileContents(RFs& aFs, const TDesC& aFileName);
 
   738 #ifndef __NFE_MEDIA_DRIVER_PRESENT__
 
       
   739 TBool   CheckBufferContents(const TDesC8& aBuffer, TUint aPrintBaseAddr=0);
 
   725 TBool   CheckBufferContents(const TDesC8& aBuffer, TUint aPrintBaseAddr=0);
 
   740 #endif
 
       
   741 
   726 
   742 /**
 
   727 /**
 
   743 Testing unallocated data initialization vulnerability in RFile
 
   728 Testing unallocated data initialization vulnerability in RFile
 
   744 This test is performed on RAM drives and non-removable media that supports DeleteNotify (KMediaAttDeleteNotify flag)
 
   729 This test is performed on RAM drives and non-removable media that supports DeleteNotify (KMediaAttDeleteNotify flag)
 
   745 e.g. XSR NAND
 
   730 e.g. XSR NAND
 
   746 */
 
   731 */
 
   747 static void Test14()
 
   732 LOCAL_C void Test14()
 
   748 {
 
   733 {
 
       
   734 	TInt nRes;
 
   749 
   735 
   750 	test.Next(_L("Testing unallocated data initialization vulnerability in RFile"));
 
   736 	test.Next(_L("Testing unallocated data initialization vulnerability in RFile"));
 
   751 
   737 
       
   738 	TDriveList driveList;
 
   752 	TDriveInfo driveInfo;
 
   739 	TDriveInfo driveInfo;
 
   753 
   740 
       
   741 	//-- 1. get drives list
 
       
   742 	nRes=TheFs.DriveList(driveList);
 
       
   743     test(nRes == KErrNone);
 
       
   744 
       
   745 	//-- 2. walk through all drives, performing the test only on suitable ones
 
       
   746 	for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum)
 
       
   747     {
 
       
   748 	    if(!driveList[drvNum])
 
       
   749 	        continue;   //-- skip unexisting drive
 
       
   750 
   754 	    //-- get drive info
 
   751 	    //-- get drive info
 
   755 	test(TheFs.Drive(driveInfo, gDriveNum) == KErrNone);
 
   752 	    test(TheFs.Drive(driveInfo, drvNum) == KErrNone);
 
   756 
   753 
   757     const TBool bMediaSuitable = (driveInfo.iType == EMediaRam)     || //-- RAM drives should be tested
 
   754 	    //-- select a suitable drive for the testing. It shall be RAM drive, of FLASH but not removable
 
   758                                  (driveInfo.iType == EMediaFlash)   || //-- NOR FLASH drives should be tested
 
   755 	    //-- and not read only, if it is FLASH, it shall support "Delete Notify" facility
 
   759                                  (driveInfo.iType == EMediaNANDFlash && driveInfo.iMediaAtt & KMediaAttDeleteNotify); //-- NAND media with DeleteNotify support
 
   756         switch(driveInfo.iType)
 
   760     
   757         {
 
   761     if(!bMediaSuitable)
 
   758         //-- RAM drive, OK
 
   762     {
 
   759         case EMediaRam:
 
   763         test.Printf(_L("This test can't be performed on this type of the media! Skipping.\n"));
 
   760         break;
 
   764         return;
 
   761 
   765     }
 
   762         //-- FLASH drive, OK
 
   766     
   763         case EMediaFlash:
 
   767     DoTest14(gDriveNum);
 
   764         case EMediaNANDFlash:
 
       
   765             if(driveInfo.iMediaAtt & KMediaAttDeleteNotify)
 
       
   766                 break; //-- this type of media shall support DeleteNotify flag, otherwise this test is inconsistent
 
       
   767             else continue;
 
       
   768 
       
   769         //break; //unreacable
 
       
   770 
       
   771         default:
 
       
   772             continue;
 
       
   773         }//switch(driveInfo.iType)
 
       
   774 
       
   775 		if (driveInfo.iDriveAtt	& KDriveAttSubsted)
 
       
   776 			{
 
       
   777 			// skip subst drives.
 
       
   778 			continue;
 
       
   779 			}
 
       
   780 
       
   781         TBool readOnly = driveInfo.iMediaAtt & KMediaAttWriteProtected;
 
       
   782         if(readOnly)
 
       
   783             continue; //-- nothing to do, can't create any file etc.
 
       
   784 
       
   785         //-- skip test on the emulator's C: drive, doesn't make any sense because
 
       
   786         //-- in this case we deal with WIN32 API and filesystem.
 
       
   787         #ifdef __WINS__
 
       
   788         if(drvNum == 2)
 
       
   789         {
 
       
   790              test.Printf(_L("Skipping test on emulator's C: drive\n"));
 
       
   791              continue;
 
       
   792         }
 
       
   793         #endif
 
       
   794 
       
   795         DoTest14(drvNum);
 
       
   796 
       
   797     }// for (TInt drvNum=0; ...
 
       
   798 
   768 }
 
   799 }
 
   769 
   800 
   770 //--------------------------------------------------------
 
   801 //--------------------------------------------------------
 
   771 
   802 
   772 /**
 
   803 /**
 
   793     //==============================
 
   824     //==============================
 
   794     test.Printf(_L("Testing scenario 1\n"));
 
   825     test.Printf(_L("Testing scenario 1\n"));
 
   795 
   826 
   796     //-- 1. create an empty file
 
   827     //-- 1. create an empty file
 
   797     nRes = CreateEmptyFile(TheFs, fileName, KFileSize);
 
   828     nRes = CreateEmptyFile(TheFs, fileName, KFileSize);
 
   798     test_KErrNone(nRes);
 
   829     test(nRes == KErrNone);
 
   799 
   830 
   800 #ifndef __NFE_MEDIA_DRIVER_PRESENT__	// can't easily check for illegitimate information if drive is encrypted
 
       
   801     //-- 1.1  check that this file doesn't contain illegitimate information.
 
   831     //-- 1.1  check that this file doesn't contain illegitimate information.
 
   802     nRes = CheckFileContents(TheFs, fileName);
 
   832     nRes = CheckFileContents(TheFs, fileName);
 
   803     test_KErrNone(nRes);
 
   833     test(nRes == KErrNone);
 
   804 #endif
 
       
   805 
   834 
   806     //-- 1.2 delete the empty file
 
   835     //-- 1.2 delete the empty file
 
   807     nRes = TheFs.Delete(fileName);
 
   836     nRes = TheFs.Delete(fileName);
 
   808     test_KErrNone(nRes);
 
   837     test(nRes == KErrNone);
 
   809 
   838 
   810     //==============================
 
   839     //==============================
 
   811     //== Scenario 2.
 
   840     //== Scenario 2.
 
   812     //== Create file, filling it with some pattern.
 
   841     //== Create file, filling it with some pattern.
 
   813     //== Delete this file, FreeClusterListL() will be involved.
 
   842     //== Delete this file, FreeClusterListL() will be involved.
 
   816     //==============================
 
   845     //==============================
 
   817     test.Printf(_L("Testing scenario 2\n"));
 
   846     test.Printf(_L("Testing scenario 2\n"));
 
   818 
   847 
   819     //-- 2. create file filled with some data pattern
 
   848     //-- 2. create file filled with some data pattern
 
   820     nRes = CreateStuffedFile(TheFs, fileName, KFileSize);
 
   849     nRes = CreateStuffedFile(TheFs, fileName, KFileSize);
 
   821     test_KErrNone(nRes);
 
   850     test(nRes == KErrNone);
 
   822 
   851 
   823     //-- 2.1 delete this file
 
   852     //-- 2.1 delete this file
 
   824     TheFs.Delete(fileName);
 
   853     TheFs.Delete(fileName);
 
   825 
   854 
   826     //-- 2.1 create an empty file on the place of just deleted one (hopefully)
 
   855     //-- 2.1 create an empty file on the place of just deleted one (hopefully)
 
   827     nRes = CreateEmptyFile(TheFs, fileName, KFileSize);
 
   856     nRes = CreateEmptyFile(TheFs, fileName, KFileSize);
 
   828     test_KErrNone(nRes);
 
   857     test(nRes == KErrNone);
 
   829 
   858 
   830     //-- 2.2  check that this file doesn't contain illegitimate information.
 
   859     //-- 2.2  check that this file doesn't contain illegitimate information.
 
   831     nRes = CheckFileContents(TheFs, fileName);
 
   860     nRes = CheckFileContents(TheFs, fileName);
 
   832     test_KErrNone(nRes);
 
   861     test(nRes == KErrNone);
 
   833 
   862 
   834     //-- 2.3 delete this file
 
   863     //-- 2.3 delete this file
 
   835     TheFs.Delete(fileName);
 
   864     TheFs.Delete(fileName);
 
   836 
   865 
   837 }
 
   866 }
 
   838 
   867 
   839 static void Test15()
 
   868 LOCAL_C void Test15()
 
   840 //
 
   869 //
 
   841 // Test IsValidName
 
   870 // Test IsValidName
 
   842 //
 
   871 //
 
   843 	{
 
   872 	{
 
   844 	test.Next(_L("Test RFs::IsValidName(TDesC& ,RFs::TNameValidParam& )"));
 
   873 	test.Next(_L("Test RFs::IsValidName(TDesC& ,RFs::TNameValidParam& )"));
 
  1131 void TestGetMediaSerialNumber()
 
  1160 void TestGetMediaSerialNumber()
 
  1132     {
 
  1161     {
 
  1133 	test.Next(_L("Test RFs::GetMediaSerialNumber"));	
  1162 	test.Next(_L("Test RFs::GetMediaSerialNumber"));	
  1134     TInt theDrive;
 
  1163     TInt theDrive;
 
  1135     TInt r = TheFs.CharToDrive(gDriveToTest,theDrive);
 
  1164     TInt r = TheFs.CharToDrive(gDriveToTest,theDrive);
 
  1136     test_KErrNone(r);
 
  1165     test(r == KErrNone);
 
  1137     TMediaSerialNumber serNum;
 
  1166     TMediaSerialNumber serNum;
 
  1138     r = TheFs.GetMediaSerialNumber(serNum, theDrive);
 
  1167     r = TheFs.GetMediaSerialNumber(serNum, theDrive);
 
  1139 	if (r) test.Printf(_L("RFs::GetMediaSerialNumber returned error %d"), r);
 
  1168 	if (r) test.Printf(_L("RFs::GetMediaSerialNumber returned error %d"), r);
 
  1140     test_Value(r, r == KErrNotSupported || r == KErrNotReady || r == KErrNone);
 
  1169     test(r == KErrNotSupported || r == KErrNotReady || r == KErrNone);
 
  1141     if (r == KErrNotSupported)
 
  1170     if (r == KErrNotSupported)
 
  1142         {
 
  1171         {
 
  1143         test.Printf(_L("MediaSerialNumber: Not Supported\n"));
 
  1172         test.Printf(_L("MediaSerialNumber: Not Supported\n"));
 
  1144         }
 
  1173         }
 
  1145     else
 
  1174     else
 
  1167     }
 
  1196     }
 
  1168 
  1197 
  1169 
  1198 
  1170 //--------------------------------------------------------
 
  1199 //--------------------------------------------------------
 
  1171 
  1200 
       
  1201 /**
 
       
  1202     Create an empty file of specified size.
 
       
  1203     @param  aFs		    ref. to the FS
 
       
  1204     @param  aFileName   name of the file
 
       
  1205     @param  aFileSize   size of the file to be created
 
       
  1206     @return    KErrNone on success, system-wide error code otherwise
 
       
  1207 */
 
       
  1208 TInt CreateEmptyFile(RFs& aFs, const TDesC& aFileName, TUint aFileSize)
 
       
  1209 {
 
       
  1210     RFile   file;
 
       
  1211 	TInt    nRes;
 
       
  1212 
       
  1213 	nRes = file.Create(aFs, aFileName, EFileRead|EFileWrite);
 
       
  1214     if(nRes != KErrNone)
 
       
  1215         return nRes;
 
       
  1216 
       
  1217 	nRes = file.SetSize(aFileSize);
 
       
  1218     if(nRes != KErrNone)
 
       
  1219         return nRes;
 
       
  1220 
       
  1221     file.Close();
 
       
  1222 
       
  1223     return KErrNone;
 
       
  1224 }
 
       
  1225 
       
  1226 //--------------------------------------------------------
 
  1172 
  1227 
  1173 /**
 
  1228 /**
 
  1174     Create a file of specified size filled with some data pattern.
 
  1229     Create a file of specified size filled with some data pattern.
 
  1175     @param  aFs		    ref. to the FS
 
  1230     @param  aFs		    ref. to the FS
 
  1176     @param  aFileName   name of the file
 
  1231     @param  aFileName   name of the file
 
  1181 {
 
  1236 {
 
  1182 	TInt    nRes;
 
  1237 	TInt    nRes;
 
  1183     RFile   file;
 
  1238     RFile   file;
 
  1184 
  1239 
  1185 	//-- create a buffer with some data
 
  1240 	//-- create a buffer with some data
 
       
  1241 	const TUint KBufLength = 0x100;
 
  1186 	TBuf8<KBufLength> buffer;
 
  1242 	TBuf8<KBufLength> buffer;
 
  1187 	buffer.SetLength(KBufLength);
 
  1243 	buffer.SetLength(KBufLength);
 
  1188 
  1244 
  1189     TUint i;
 
  1245     TUint i;
 
  1190 
  1246 
  1231 TInt   CheckFileContents(RFs& aFs, const TDesC& aFileName)
 
  1287 TInt   CheckFileContents(RFs& aFs, const TDesC& aFileName)
 
  1232 {
 
  1288 {
 
  1233 	TInt    nRes = KErrNone;
 
  1289 	TInt    nRes = KErrNone;
 
  1234     RFile   file;
 
  1290     RFile   file;
 
  1235 
  1291 
       
  1292 	const TInt KBufLength = 0x100;
 
  1236 	TBuf8<KBufLength> buffer;
 
  1293 	TBuf8<KBufLength> buffer;
 
  1237     buffer.SetLength(0);
 
  1294     buffer.SetLength(0);
 
  1238 
  1295 
  1239     //-- open the file
 
  1296     //-- open the file
 
  1240     nRes = file.Open(aFs, aFileName, EFileRead);
 
  1297     nRes = file.Open(aFs, aFileName, EFileRead);
 
  1241     test_KErrNone(nRes);
 
  1298     test(nRes == KErrNone);
 
  1242 
  1299 
  1243     //-- check file contents
 
  1300     //-- check file contents
 
  1244     TUint nFilePos=0;
 
  1301     TUint nFilePos=0;
 
  1245     for(;;)
 
  1302     for(;;)
 
  1246     {
 
  1303     {
 
  1247         //-- read data from the file into the buffer
 
  1304         //-- read data from the file into the buffer
 
  1248         nRes = file.Read(buffer);
 
  1305         nRes = file.Read(buffer);
 
  1249         test_KErrNone(nRes);
 
  1306         test(nRes == KErrNone);
 
  1250 
  1307 
  1251         if(buffer.Length() == 0)
 
  1308         if(buffer.Length() == 0)
 
  1252         {
 
  1309         {
 
  1253             nRes = KErrNone; //-- read all the file, no illegitimate information found
 
  1310             nRes = KErrNone; //-- read all the file, no illegitimate information found
 
  1254             break; //EOF
 
  1311             break; //EOF
 
  1255         }
 
  1312         }
 
  1256 
  1313 
  1257 #ifdef __NFE_MEDIA_DRIVER_PRESENT__
 
       
  1258 		// check the buffer doesn't contain the same pattern written to it by CreateStuffedFile()
 
       
  1259 		TUint i;
 
       
  1260 		for(i = 0; i < KBufLength; i++)
 
       
  1261 			if (buffer[i] != static_cast<TUint8> (i))
 
       
  1262 				break;
 
       
  1263 		if (i == KBufLength)
 
       
  1264 			{
 
       
  1265             nRes = KErrCorrupt; //-- indicate that the read buffer contains illegitimate information
 
       
  1266             break; //-- comment this out if you need a full dump of the file
 
       
  1267 			}
 
       
  1268 #else
 
       
  1269         //-- check if the buffer contains only allowed data (RAM page initialisation data, etc. e.g. 0x00, 0xff, 0x03, 0xcc)
 
  1314         //-- check if the buffer contains only allowed data (RAM page initialisation data, etc. e.g. 0x00, 0xff, 0x03, 0xcc)
 
  1270         if(!CheckBufferContents(buffer, nFilePos))
 
  1315         if(!CheckBufferContents(buffer, nFilePos))
 
  1271         {
 
  1316         {
 
  1272             test.Printf(_L("\nCheckFileContents failed ! The file contains illegitimate information!\n"));
 
  1317             test.Printf(_L("\nCheckFileContents failed ! The file contains illegitimate information!\n"));
 
  1273             nRes = KErrCorrupt; //-- indicate that the read buffer contains illegitimate information
 
  1318             nRes = KErrCorrupt; //-- indicate that the read buffer contains illegitimate information
 
  1274             break; //-- comment this out if you need a full dump of the file
 
  1319             break; //-- comment this out if you need a full dump of the file
 
  1275         }
 
  1320         }
 
  1276 #endif
 
       
  1277 
  1321 
  1278         nFilePos+=buffer.Length();
 
  1322         nFilePos+=buffer.Length();
 
  1279     }
 
  1323     }
 
  1280 
  1324 
  1281     file.Close();
 
  1325     file.Close();
 
  1295 {
 
  1339 {
 
  1296     TBool bRes = ETrue;
 
  1340     TBool bRes = ETrue;
 
  1297 
  1341 
  1298     //-- check if the buffer filled with allowable data (RAM page initialisation data or something similar)
 
  1342     //-- check if the buffer filled with allowable data (RAM page initialisation data or something similar)
 
  1299     //-- but not something meaningful.
 
  1343     //-- but not something meaningful.
 
  1300     //-- Actually, the buffer should be filled with uniformed bytes (most probably, 0x00)
 
  1344     //-- allowable bytes: 0x00, 0x03, 0xff, 0xcc
 
  1301     for(TInt i=0; i<aBuffer.Size(); ++i)
 
  1345     for(TInt i=0; i<aBuffer.Size(); ++i)
 
  1302     {
 
  1346     {
 
  1303         TUint8 byte = aBuffer[i];
 
  1347         TUint8 byte = aBuffer[i];
 
  1304         if(byte != aBuffer[0])
 
  1348         if(byte != 0x00 && byte != 0x03 && byte != 0xff && byte != 0xcc )
 
  1305         {
 
  1349         {
 
  1306             bRes = EFalse;
 
  1350             bRes = EFalse;
 
  1307             break;
 
  1351             break;
 
  1308         }
 
  1352         }
 
  1309     }
 
  1353     }
 
  1326 	}
 
  1370 	}
 
  1327 
  1371 
  1328     return bRes;
 
  1372     return bRes;
 
  1329 }
 
  1373 }
 
  1330 
  1374 
  1331 //--------------------------------------------------------
 
  1375 
  1332 /**
 
  1376 GLDEF_C void CallTestsL()
 
  1333     Check if the drive aDriveNo is finalised or not.
 
  1377 //
 
  1334     The "CleanShutDown" is obtained by QueryVolumeInfoExt API which is FS-agnostic.
 
  1378 // Call tests that may leave
 
  1335 
  1379 //
 
  1336     @param  aDriveNo drive number to query.
 
  1380 	{
 
  1337     @return ETrue if the drive if finalised
 
  1381 
  1338 */
 
       
  1339 static TBool IsVolumeFinalised(TInt aDriveNo)
 
       
  1340 {
 
       
  1341     TInt nRes;
 
       
  1342     TPckgBuf<TBool> boolPckg;
 
       
  1343 
       
  1344     //-- 1. get "Finalised" state by using the API
 
       
  1345     nRes = TheFs.QueryVolumeInfoExt(aDriveNo, EIsDriveFinalised, boolPckg);
 
       
  1346     test_KErrNone(nRes);
 
       
  1347     
       
  1348     return boolPckg();
 
       
  1349 }
 
       
  1350 
       
  1351 
       
  1352 //--------------------------------------------------------
 
       
  1353 /**
 
       
  1354     This is a file system - agnostic test that verifies RFs::FinaliseDrive() API
 
       
  1355     There are also file system - specific tests that check similar functionallity (see t_mount for example)
 
       
  1356 
       
  1357 */
 
       
  1358 void TestDriveFinalisation()
 
       
  1359 {
 
       
  1360     test.Next(_L("TestDriveFinalisation(). Testing RFs::FinaliseDrives() API\n"));    
       
  1361     
       
  1362 
       
  1363     if((!Is_Fat(TheFs, gDriveNum) && !Is_ExFat(TheFs, gDriveNum)) || Is_Fat12(TheFs, gDriveNum) )
 
       
  1364     {
 
       
  1365         test.Printf(_L("This test can't be performed on current file system, skipping.\n"));
 
       
  1366         return;
 
       
  1367     }
 
       
  1368 
       
  1369     TVolumeInfo v;
 
       
  1370     TInt  nRes;
 
       
  1371 
       
  1372     nRes = TheFs.Volume(v);
 
       
  1373     test(nRes==KErrNone);
 
       
  1374 
       
  1375     if(v.iDrive.iMediaAtt & KMediaAttVariableSize)
 
       
  1376         {
 
       
  1377         test.Printf(_L("Skipping. RAM drive not tested.\n"));
 
       
  1378         return;
 
       
  1379         }
 
       
  1380 
       
  1381 
       
  1382     TBool bDriveFinalised;
 
       
  1383 
       
  1384     //============= 1. finalise the drive (RW mode) and check the result
 
       
  1385     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1386     test_KErrNone(nRes);
 
       
  1387 
       
  1388     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1389     test(bDriveFinalised);
 
       
  1390 
       
  1391     //-- 1.1 finalise the drive second time EFinal_RW -> EFinal_RW shall work
 
       
  1392     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1393     test_KErrNone(nRes);
 
       
  1394 
       
  1395     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1396     test(bDriveFinalised);
 
       
  1397 
       
  1398     //============= 2. create a file. Shall succeed (EFinal_RW), the volume shall become unfinalised
 
       
  1399 
       
  1400     RFile file;
 
       
  1401     _LIT(KFileName, "\\my_file1.dat");
 
       
  1402     _LIT8(KSomeData, "this is some data");
 
       
  1403 
       
  1404     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1405     test_KErrNone(nRes);
 
       
  1406 
       
  1407     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1408     test(!bDriveFinalised); //-- the volume has become "unfinalised"
 
       
  1409 
       
  1410     //----------------------------------------------------------------------------------
 
       
  1411     //-- test volume finalisation with opened objects
 
       
  1412 
       
  1413     //-- 2.1 having opened files should be OK for volume finalisation
 
       
  1414     
       
  1415     //-- 2.1.1 RW finalisation; after the volume finalised it should be possible to write to the opened file
 
       
  1416     nRes = file.Open(TheFs, KFileName, EFileWrite | EFileWriteDirectIO);
 
       
  1417     test_KErrNone(nRes);
 
       
  1418 
       
  1419     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1420     test_KErrNone(nRes);
 
       
  1421 
       
  1422     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1423     test(bDriveFinalised);
 
       
  1424 
       
  1425     nRes = file.Write(0, KSomeData);
 
       
  1426     test_KErrNone(nRes);
 
       
  1427 
       
  1428     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1429     test(!bDriveFinalised); //-- the volume should become "unfinalised"
 
       
  1430 
       
  1431     //-- 2.1.2 RO finalisation; after the volume finalised it shouldn't be possible to write to the opened file
 
       
  1432     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RO);
 
       
  1433     test_KErrNone(nRes);
 
       
  1434 
       
  1435     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1436     test(bDriveFinalised);
 
       
  1437 
       
  1438     nRes = file.Write(0, KSomeData);
 
       
  1439     test(nRes == KErrAccessDenied);  //-- no write access to the volume
 
       
  1440 
       
  1441     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1442     test(bDriveFinalised); //-- the volume should become "unfinalised"
 
       
  1443 
       
  1444     file.Close();
 
       
  1445     
       
  1446     //-- remount FS, the drive shall become RW
 
       
  1447     nRes = RemountFS(TheFs, gDriveNum);
 
       
  1448     test_KErrNone(nRes);
 
       
  1449     
       
  1450     
       
  1451     //-- 2.2 having opened directories should be OK for volume finalisation
 
       
  1452     _LIT(KDirName,  "\\Dir11235tt\\");
 
       
  1453     MakeDir(KDirName);
 
       
  1454     RDir dir;
 
       
  1455 
       
  1456     //-- 2.2.1 RW finalisation; after the volume finalised it should be possible to have write access to it
 
       
  1457     nRes = dir.Open(TheFs, KDirName, KEntryAttNormal);
 
       
  1458     test_KErrNone(nRes);
 
       
  1459 
       
  1460     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1461     test_KErrNone(nRes);
 
       
  1462 
       
  1463     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1464     test(bDriveFinalised);
 
       
  1465 
       
  1466     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1467     test_KErrNone(nRes);
 
       
  1468 
       
  1469     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1470     test(!bDriveFinalised);
 
       
  1471 
       
  1472     //-- 2.1.2 RO finalisation; after the volume finalised it shouldn't be possible to write to it
 
       
  1473     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RO);
 
       
  1474     test_KErrNone(nRes);
 
       
  1475 
       
  1476     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1477     test(bDriveFinalised);
 
       
  1478 
       
  1479     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1480     test(nRes == KErrAccessDenied);  //-- no write access to the volume
 
       
  1481 
       
  1482     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1483     test(bDriveFinalised); //-- the volume should become "unfinalised"
 
       
  1484 
       
  1485     dir.Close();
 
       
  1486 
       
  1487     //-- remount FS, the drive shall become RW
 
       
  1488     nRes = RemountFS(TheFs, gDriveNum);
 
       
  1489     test_KErrNone(nRes);
 
       
  1490     
       
  1491     //-- 2.3 having opened disk access objects, like formats or raw disks makes finalisation impossible
 
       
  1492     RFormat  format;
 
       
  1493     RRawDisk rawDisk;
 
       
  1494     TInt     fmtCnt;
 
       
  1495 
       
  1496     //-- 2.3.1 format
 
       
  1497     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1498     test_KErrNone(nRes);
 
       
  1499 
       
  1500     nRes = format.Open(TheFs, gSessionPath, EFullFormat, fmtCnt);
 
       
  1501     test_KErrNone(nRes);
 
       
  1502 
       
  1503     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1504     test(nRes == KErrInUse);  
       
  1505 
       
  1506     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RO);
 
       
  1507     test(nRes == KErrInUse);  
       
  1508 
       
  1509     format.Close();
 
       
  1510 
       
  1511     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1512     test_KErrNone(nRes);
 
       
  1513 
       
  1514     //-- 2.3.2 raw disk
 
       
  1515     nRes = rawDisk.Open(TheFs, gDriveNum);
 
       
  1516     test_KErrNone(nRes);
 
       
  1517 
       
  1518 
       
  1519     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1520     test(nRes == KErrInUse);  
       
  1521 
       
  1522     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RO);
 
       
  1523     test(nRes == KErrInUse);  
       
  1524     
       
  1525     rawDisk.Close();
 
       
  1526 
       
  1527     //-- 2.4 Volume finalisation and file system dismounting
 
       
  1528 
       
  1529     //-- 2.4.1 "graceful" dismounting should finalise the drive correctly
 
       
  1530 
       
  1531     //-- "unfinalise the volume"
 
       
  1532     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1533     test_KErrNone(nRes);
 
       
  1534 
       
  1535     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1536     test(!bDriveFinalised);
 
       
  1537 
       
  1538     TFSDescriptor fsDesc;
 
       
  1539     nRes = GetFileSystemDescriptor(TheFs, gDriveNum, fsDesc);
 
       
  1540     test_KErrNone(nRes);
 
       
  1541 
       
  1542     //-- gracefully dismount the file system
 
       
  1543     nRes = TheFs.DismountFileSystem(fsDesc.iFsName, gDriveNum);
 
       
  1544     test_KErrNone(nRes);
 
       
  1545 
       
  1546     //-- mount it back
 
       
  1547     nRes = MountFileSystem(TheFs, gDriveNum, fsDesc);
 
       
  1548     test_KErrNone(nRes);
 
       
  1549 
       
  1550     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1551     test(bDriveFinalised);
 
       
  1552 
       
  1553     //-- 2.4.2 "forced" dismounting, usually happens when "graceful doesn't work, because there are files opened on the volume.
 
       
  1554     //-- Should also finalise the drive correctly
 
       
  1555 
       
  1556     //-- "unfinalise the volume"
 
       
  1557     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1558     test_KErrNone(nRes);
 
       
  1559 
       
  1560     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1561     test(!bDriveFinalised);
 
       
  1562 
       
  1563     //-- open a file on the volume, this will prevent graceful dismounting
 
       
  1564     nRes = file.Open(TheFs, KFileName, EFileWrite | EFileWriteDirectIO);
 
       
  1565     test_KErrNone(nRes);
 
       
  1566 
       
  1567     nRes = GetFileSystemDescriptor(TheFs, gDriveNum, fsDesc);
 
       
  1568     test_KErrNone(nRes);
 
       
  1569 
       
  1570     //-- try gracefully dismount the file system
 
       
  1571     nRes = TheFs.DismountFileSystem(fsDesc.iFsName, gDriveNum);
 
       
  1572     test(nRes == KErrInUse); //-- no luck, as expected
 
       
  1573 
       
  1574     //-- now do dismounting by force
 
       
  1575     TRequestStatus  rqStat;
 
       
  1576     TheFs.NotifyDismount(gDriveNum, rqStat, EFsDismountForceDismount);
 
       
  1577     User::WaitForRequest(rqStat);
 
       
  1578     test_KErrNone(rqStat.Int());
 
       
  1579 
       
  1580     nRes = file.Write(0, KSomeData);
 
       
  1581     test(nRes == KErrNotReady);    
       
  1582 
       
  1583     file.Close();
 
       
  1584 
       
  1585     //-- mount it back
 
       
  1586     nRes = MountFileSystem(TheFs, gDriveNum, fsDesc);
 
       
  1587     test_KErrNone(nRes);
 
       
  1588 
       
  1589     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1590     test(bDriveFinalised);
 
       
  1591 
       
  1592     //============= 3. test "unfinalise API"
 
       
  1593     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EForceUnfinalise);
 
       
  1594     test_KErrNone(nRes);
 
       
  1595 
       
  1596     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1597     test(!bDriveFinalised); //-- the volume has become "unfinalised"
 
       
  1598 
       
  1599     //============= 4. test finalisation into RO mode
 
       
  1600     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RO); //-- the volume becomes RO
 
       
  1601     test_KErrNone(nRes);
 
       
  1602 
       
  1603     //-- try to write a file on RO volume; it shall fail with KErrAccessDenied
 
       
  1604     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1605     test(nRes == KErrAccessDenied);
 
       
  1606     file.Close();
 
       
  1607 
       
  1608     //-- 4.1 try to finalise into EFinal_RW mode, shall fail with KErrAccessDenied
 
       
  1609     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1610     test(nRes == KErrAccessDenied);
 
       
  1611 
       
  1612     //-- 4.2 "unfinalise" the volume, it still shall remain RO
 
       
  1613     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EForceUnfinalise);
 
       
  1614     test_KErrNone(nRes);
 
       
  1615 
       
  1616     //-- try to write a file on RO volume; it shall fail with KErrAccessDenied
 
       
  1617     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1618     test(nRes == KErrAccessDenied);
 
       
  1619     file.Close();
 
       
  1620 
       
  1621     //-- remount FS, the drive shall become RW
 
       
  1622     nRes = RemountFS(TheFs, gDriveNum);
 
       
  1623     test_KErrNone(nRes);
 
       
  1624 
       
  1625     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1626     test(bDriveFinalised);
 
       
  1627 
       
  1628     //-- try to write a file on RW volume, shall be OK
 
       
  1629     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1630     test(nRes == KErrNone);
 
       
  1631     file.Close();
 
       
  1632 
       
  1633     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1634     test(!bDriveFinalised);
 
       
  1635 
       
  1636     //============= 5. test various finalisation modes
 
       
  1637 
       
  1638     //-- 5.1  Not finalised -> EFinal_RW (KErrNone)
 
       
  1639     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1640     test(nRes == KErrNone);
 
       
  1641     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1642     test(bDriveFinalised);
 
       
  1643 
       
  1644     //-- 5.2  EFinal_RW -> EFinal_RO (KErrNone)
 
       
  1645     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RO);
 
       
  1646     test(nRes == KErrNone);
 
       
  1647     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1648     test(bDriveFinalised);
 
       
  1649 
       
  1650     //-- 5.2  EFinal_RO -> EFinal_RW  (KErrAccessDenied)
 
       
  1651     nRes =TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW);
 
       
  1652     test(nRes == KErrAccessDenied);
 
       
  1653     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1654     test(bDriveFinalised);
 
       
  1655 
       
  1656     //-- 5.3 restore
 
       
  1657     nRes = RemountFS(TheFs, gDriveNum);
 
       
  1658     test_KErrNone(nRes);
 
       
  1659 
       
  1660 
       
  1661     //============= 6. test old RFs::FinaliseDrives API
 
       
  1662 
       
  1663     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1664     test(nRes == KErrNone);
 
       
  1665 
       
  1666     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1667     test(!bDriveFinalised);
 
       
  1668 
       
  1669     TheFs.FinaliseDrives(); //-- shall work as TheFs.FinaliseDrive(gDriveNum, RFs::EFinal_RW) but for ALL drives
 
       
  1670 
       
  1671     bDriveFinalised = IsVolumeFinalised(gDriveNum);
 
       
  1672     test(bDriveFinalised);
 
       
  1673 
       
  1674     nRes = CreateEmptyFile(TheFs, KFileName, 128000);
 
       
  1675     test(nRes == KErrNone);
 
       
  1676 
       
  1677 
       
  1678 
       
  1679 }
 
       
  1680 
       
  1681 
       
  1682 void CallTestsL()
 
       
  1683 	{
 
       
  1684     //-- set up console output
 
       
  1685     F32_Test_Utils::SetConsole(test.Console());
 
       
  1686 
       
  1687     TInt nRes=TheFs.CharToDrive(gDriveToTest, gDriveNum);
 
       
  1688     test_KErrNone(nRes);
 
       
  1689     
       
  1690     PrintDrvInfo(TheFs, gDriveNum);
 
       
  1691 
       
  1692     TestDriveFinalisation();
 
       
  1693 	Test1();
 
  1382 	Test1();
 
  1694 	Test2();
 
  1383 	Test2();
 
  1695 	Test3();
 
  1384 	Test3();
 
  1696 	Test4();
 
  1385 	Test4();
 
  1697 	Test5();
 
  1386 	Test5();
 
  1704 	Test12();
 
  1393 	Test12();
 
  1705 	Test13();
 
  1394 	Test13();
 
  1706 	Test14();
 
  1395 	Test14();
 
  1707 	Test15();
 
  1396 	Test15();
 
  1708     TestGetMediaSerialNumber();
 
  1397     TestGetMediaSerialNumber();
 
  1709 
  1398 	}
 
  1710 	}
FCL/sf/os/kernelhwsrv