Mercurial Mercurial > oss > MCL > sf > os > kernelhwsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
kerneltest/f32test/server/t_misc.cpp
branchRCL_3
changeset 43 c1f20ce4abcf
parent 42 a179b74831c9
child 44 3e88ff8f41d5
equal deleted inserted replaced
42:a179b74831c9 43:c1f20ce4abcf 
    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__
 
    18 #include <f32file.h>
 
    19 #include <f32file.h>
 
    19 #include <e32test.h>
 
    20 #include <e32test.h>
 
    20 #include "t_server.h"
 
    21 #include "t_server.h"
 
       
    22 
       
    23 #include "f32_test_utils.h"
 
       
    24 using namespace F32_Test_Utils;
 
       
    25 
    21 
    26 
    22 // If there is an NFE media driver present, then because of the way EDeleteNotify requests work,
 
    27 // If there is an NFE media driver present, then because of the way EDeleteNotify requests work,
 
    23 // the data retrieved from a deleted file will not be a buffer full of zero's, but instead a buffer
 
    28 // the data retrieved from a deleted file will not be a buffer full of zero's, but instead a buffer
 
    24 // full of decrypted zero's
 
    29 // full of decrypted zero's
 
    25 #define __NFE_MEDIA_DRIVER_PRESENT__
 
    30 #define __NFE_MEDIA_DRIVER_PRESENT__
 
    27 #ifdef __VC32__
 
    32 #ifdef __VC32__
 
    28     // Solve compilation problem caused by non-English locale
 
    33     // Solve compilation problem caused by non-English locale
 
    29     #pragma setlocale("english")
 
    34     #pragma setlocale("english")
 
    30 #endif
 
    35 #endif
 
    31 
    36 
    32 GLDEF_D RTest test(_L("T_MISC"));
 
    37 RTest test(_L("T_MISC"));
 
    33 
    38 
       
    39 
       
    40 TInt gDriveNum = -1;
 
    34 const TUint KBufLength = 0x100;
 
    41 const TUint KBufLength = 0x100;
 
    35 
    42 
    36 LOCAL_C void Test1()
 
    43 static void Test1()
 
    37 //
 
    44 //
 
    38 // Open, write to and read from a file
 
    45 // Open, write to and read from a file
 
    39 //
 
    46 //
 
    40 	{
 
    47 	{
 
    41 
    48 
    42 	test.Next(_L("Open, write to and read from a file"));
 
    49 	test.Next(_L("Open, write to and read from a file"));
 
    43 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    50 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    44 	test(r==KErrNone);
 
    51 	test_KErrNone(r);
 
    45 	RFile file;
 
    52 	RFile file;
 
    46 	r=file.Create(TheFs,_L("Hello.Wld"),EFileWrite);
 
    53 	r=file.Create(TheFs,_L("Hello.Wld"),EFileWrite);
 
    47 	test(r==KErrNone);
 
    54 	test_KErrNone(r);
 
    48 	r=file.Write(_L8("Hello World"),11);
 
    55 	r=file.Write(_L8("Hello World"),11);
 
    49 	test(r==KErrNone);
 
    56 	test_KErrNone(r);
 
    50 	file.Close();
 
    57 	file.Close();
 
    51 
    58 
    52 	r=file.Open(TheFs,_L("Hello.Wld"),EFileRead);
 
    59 	r=file.Open(TheFs,_L("Hello.Wld"),EFileRead);
 
    53 	test(r==KErrNone);
 
    60 	test_KErrNone(r);
 
    54 	TBuf8<256> buf;
 
    61 	TBuf8<256> buf;
 
    55 	r=file.Read(buf);
 
    62 	r=file.Read(buf);
 
    56 	test(r==KErrNone);
 
    63 	test_KErrNone(r);
 
    57 	test(buf==_L8("Hello World"));
 
    64 	test(buf==_L8("Hello World"));
 
    58 	file.Close();
 
    65 	file.Close();
 
    59 	}
 
    66 	}
 
    60 
    67 
    61 LOCAL_C void Test2()
 
    68 static void Test2()
 
    62 //
 
    69 //
 
    63 // Open and read from a file
 
    70 // Open and read from a file
 
    64 //
 
    71 //
 
    65 	{
 
    72 	{
 
    66 
    73 
    67 	test.Next(_L("Open and read from a file"));
 
    74 	test.Next(_L("Open and read from a file"));
 
    68 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    75 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    69 	test(r==KErrNone);
 
    76 	test_KErrNone(r);
 
    70 	RFile file;
 
    77 	RFile file;
 
    71 	r=file.Open(TheFs,_L("Hello.Wld"),EFileRead);
 
    78 	r=file.Open(TheFs,_L("Hello.Wld"),EFileRead);
 
    72 	test(r==KErrNone);
 
    79 	test_KErrNone(r);
 
    73 	TBuf8<256> buf;
 
    80 	TBuf8<256> buf;
 
    74 	r=file.Read(buf);
 
    81 	r=file.Read(buf);
 
    75 	test(r==KErrNone);
 
    82 	test_KErrNone(r);
 
    76 	test(buf==_L8("Hello World"));
 
    83 	test(buf==_L8("Hello World"));
 
    77 	file.Close();
 
    84 	file.Close();
 
    78 	r=TheFs.Delete(_L("HELLO.WLD"));
 
    85 	r=TheFs.Delete(_L("HELLO.WLD"));
 
    79 	test(r==KErrNone);
 
    86 	test_KErrNone(r);
 
    80 	}
 
    87 	}
 
    81 
    88 
    82 LOCAL_C void Test3()
 
    89 static void Test3()
 
    83 //
 
    90 //
 
    84 // Create nested directories
 
    91 // Create nested directories
 
    85 //
 
    92 //
 
    86 	{
 
    93 	{
 
    87 
    94 
    88 	test.Next(_L("Create nested directories"));
 
    95 	test.Next(_L("Create nested directories"));
 
    89 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    96 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
    90 	test(r==KErrNone);
 
    97 	test_KErrNone(r);
 
    91 	TheFs.ResourceCountMarkStart();
 
    98 	TheFs.ResourceCountMarkStart();
 
    92 //
 
    99 //
 
    93 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\A.B"));
 
   100 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\A.B"));
 
    94 	test(r==KErrNone || r==KErrAlreadyExists);
 
   101 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
    95 	r=TheFs.MkDir(_L("\\F32-TST\\RIGHT\\"));
 
   102 	r=TheFs.MkDir(_L("\\F32-TST\\RIGHT\\"));
 
    96 	test(r==KErrNone || r==KErrAlreadyExists);
 
   103 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
    97 //
 
   104 //
 
    98 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\ONE\\"));
 
   105 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\ONE\\"));
 
    99 	test(r==KErrNone || r==KErrAlreadyExists);
 
   106 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   100 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\TWO\\"));
 
   107 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\TWO\\"));
 
   101 	test(r==KErrNone || r==KErrAlreadyExists);
 
   108 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   102 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\THREE\\"));
 
   109 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\THREE\\"));
 
   103 	test(r==KErrNone || r==KErrAlreadyExists);
 
   110 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   104 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\TWO\\BOTTOM\\"));
 
   111 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\TWO\\BOTTOM\\"));
 
   105 	test(r==KErrNone || r==KErrAlreadyExists);
 
   112 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   106 //
 
   113 //
 
   107 	r=TheFs.MkDirAll(_L("\\F32-TST\\RIGHT\\TOP\\MID\\BOT\\"));
 
   114 	r=TheFs.MkDirAll(_L("\\F32-TST\\RIGHT\\TOP\\MID\\BOT\\"));
 
   108 	test(r==KErrNone || r==KErrAlreadyExists);
 
   115 	test_Value(r, r == KErrNone || r==KErrAlreadyExists);
 
   109 	}
 
   116 	}
 
   110 
   117 
   111 LOCAL_C void Test4()
 
   118 static void Test4()
 
   112 //
 
   119 //
 
   113 // Test returned error values
 
   120 // Test returned error values
 
   114 //
 
   121 //
 
   115 	{
 
   122 	{
 
   116 
   123 
   117 	test.Next(_L("Test returned error values"));
 
   124 	test.Next(_L("Test returned error values"));
 
   118 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
   125 	TInt r=TheFs.SetSessionPath(gSessionPath);
 
   119 	test(r==KErrNone);
 
   126 	test_KErrNone(r);
 
   120 	TheFs.ResourceCountMarkStart();
 
   127 	TheFs.ResourceCountMarkStart();
 
   121 //
 
   128 //
 
   122 	r=TheFs.MkDir(_L("\\"));
 
   129 	r=TheFs.MkDir(_L("\\"));
 
   123 	test(r==KErrAlreadyExists);
 
   130 	test_Value(r, r == KErrAlreadyExists);
 
   124 	r=TheFs.MkDir(_L("\\LEFT"));
 
   131 	r=TheFs.MkDir(_L("\\LEFT"));
 
   125 	test(r==KErrAlreadyExists);
 
   132 	test_Value(r, r == KErrAlreadyExists);
 
   126 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\"));
 
   133 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\"));
 
   127 	test(r==KErrAlreadyExists);
 
   134 	test_Value(r, r == KErrAlreadyExists);
 
   128 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\..\\NEWDIR\\"));
 
   135 	r=TheFs.MkDir(_L("\\F32-TST\\LEFT\\..\\NEWDIR\\"));
 
   129 	test(r==KErrBadName);
 
   136 	test_Value(r, r == KErrBadName);
 
   130 	r=TheFs.MkDir(_L("\\F32-TST\\NEWDIR\\SUBDIR\\"));
 
   137 	r=TheFs.MkDir(_L("\\F32-TST\\NEWDIR\\SUBDIR\\"));
 
   131 	test(r==KErrPathNotFound);
 
   138 	test_Value(r, r == KErrPathNotFound);
 
   132 //
 
   139 //
 
   133 	r=TheFs.RmDir(_L("\\"));
 
   140 	r=TheFs.RmDir(_L("\\"));
 
   134 	test(r==KErrInUse);
 
   141 	test_Value(r, r == KErrInUse);
 
   135 	r=TheFs.RmDir(_L("\\PROG"));
 
   142 	r=TheFs.RmDir(_L("\\PROG"));
 
   136 	test(r==KErrInUse);
 
   143 	test_Value(r, r == KErrInUse);
 
   137 	r=TheFs.RmDir(_L("\\F32-TST\\"));
 
   144 	r=TheFs.RmDir(_L("\\F32-TST\\"));
 
   138 	test(r==KErrInUse);
 
   145 	test_Value(r, r == KErrInUse);
 
   139 
   146 
   140 
   147 
   141 	RDir dir;
 
   148 	RDir dir;
 
   142 	r=dir.Open(TheFs,_L("V:\\asdf"),KEntryAttNormal);
 
   149 	r=dir.Open(TheFs,_L("V:\\asdf"),KEntryAttNormal);
 
   143 	test(r==KErrNone || r==KErrNotReady || r==KErrNotFound);
 
   150 	test_Value(r, r == KErrNone || r==KErrNotReady || r==KErrNotFound);
 
   144 	if (r==KErrNone)
 
   151 	if (r==KErrNone)
 
   145 		dir.Close();
 
   152 		dir.Close();
 
   146 	r=dir.Open(TheFs,_L("L:\\asdf"),KEntryAttNormal);
 
   153 	r=dir.Open(TheFs,_L("L:\\asdf"),KEntryAttNormal);
 
   147 	test(r==KErrNone || r==KErrNotReady || r==KErrNotFound);
 
   154 	test_Value(r, r == KErrNone || r==KErrNotReady || r==KErrNotFound);
 
   148 	dir.Close();
 
   155 	dir.Close();
 
   149 //
 
   156 //
 
   150 	TEntry entry;
 
   157 	TEntry entry;
 
   151 	r=TheFs.Entry(_L("z:\\NOTEXiSTS\\file.txt"),entry);
 
   158 	r=TheFs.Entry(_L("z:\\NOTEXiSTS\\file.txt"),entry);
 
   152 	test(r==KErrPathNotFound);
 
   159 	test_Value(r, r == KErrPathNotFound);
 
   153 	r=TheFs.Entry(_L("z:\\NOTEXiSTS\\"),entry);
 
   160 	r=TheFs.Entry(_L("z:\\NOTEXiSTS\\"),entry);
 
   154 	test(r==KErrNotFound);
 
   161 	test_Value(r, r == KErrNotFound);
 
   155 	r=TheFs.Entry(_L("z:\\SYSTEM\\"),entry);
 
   162 	r=TheFs.Entry(_L("z:\\SYSTEM\\"),entry);
 
   156 	test(r==KErrNone);
 
   163 	test_KErrNone(r);
 
   157 	r=TheFs.Entry(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("z:\\SYS\\BIN\\ESHELL.EXE"):_L("z:\\SYSTEM\\BIN\\ESHELL.EXE"),entry);
 
   164 	r=TheFs.Entry(PlatSec::ConfigSetting(PlatSec::EPlatSecEnforceSysBin)?_L("z:\\SYS\\BIN\\ESHELL.EXE"):_L("z:\\SYSTEM\\BIN\\ESHELL.EXE"),entry);
 
   158 	test(r==KErrNone);
 
   165 	test_KErrNone(r);
 
   159 
   166 
   160 	r=dir.Open(TheFs,_L("\\*"),NULL);
 
   167 	r=dir.Open(TheFs,_L("\\*"),NULL);
 
   161 	test(r==KErrNone);
 
   168 	test_KErrNone(r);
 
   162 	TEntry dirEntry;
 
   169 	TEntry dirEntry;
 
   163 	r=dir.Read(dirEntry);
 
   170 	r=dir.Read(dirEntry);
 
   164 	test(r==KErrNone || r==KErrEof);
 
   171 	test_Value(r, r == KErrNone || r==KErrEof);
 
   165 	if (r==KErrNone)
 
   172 	if (r==KErrNone)
 
   166 		test.Printf(_L("%S\n"),&dirEntry.iName);
 
   173 		test.Printf(_L("%S\n"),&dirEntry.iName);
 
   167 	dir.Close();
 
   174 	dir.Close();
 
   168 
   175 
   169 	r=dir.Open(TheFs,_L("A:\\*"),NULL);
 
   176 	r=dir.Open(TheFs,_L("A:\\*"),NULL);
 
   170 	test(r==KErrNotReady || r==KErrNone);
 
   177 	test_Value(r, r == KErrNotReady || r==KErrNone);
 
   171 	dir.Close();
 
   178 	dir.Close();
 
   172 	}
 
   179 	}
 
   173 
   180 
   174 LOCAL_C void Test5()
 
   181 static void Test5()
 
   175 //
 
   182 //
 
   176 // Read files directly from the rom
 
   183 // Read files directly from the rom
 
   177 //
 
   184 //
 
   178 
   185 
   179 	{
 
   186 	{
 
   186 
   193 
   187 	if ( TheFs.IsFileInRom(KTFileCpp) != NULL && TheFs.IsFileInRom(KTFsrvCpp) != NULL )
 
   194 	if ( TheFs.IsFileInRom(KTFileCpp) != NULL && TheFs.IsFileInRom(KTFsrvCpp) != NULL )
 
   188 		{
 
   195 		{
 
   189 		RFile f;
 
   196 		RFile f;
 
   190 		r=f.Open(TheFs,KTFileCpp,EFileRead);
 
   197 		r=f.Open(TheFs,KTFileCpp,EFileRead);
 
   191 		test(r==KErrNone);
 
   198 		test_KErrNone(r);
 
   192 		r=f.Seek(ESeekAddress,pos);
 
   199 		r=f.Seek(ESeekAddress,pos);
 
   193 		TText8* ptrPos=*(TText8**)&pos;
 
   200 		TText8* ptrPos=*(TText8**)&pos;
 
   194 		test(r==KErrNone);
 
   201 		test_KErrNone(r);
 
   195 		TBuf8<1024> readBuf;
 
   202 		TBuf8<1024> readBuf;
 
   196 		r=f.Read(readBuf);
 
   203 		r=f.Read(readBuf);
 
   197 		test(r==KErrNone);
 
   204 		test_KErrNone(r);
 
   198 		test(readBuf.Length()==readBuf.MaxLength());
 
   205 		test(readBuf.Length()==readBuf.MaxLength());
 
   199 		TPtrC8 memBuf(ptrPos,readBuf.Length());
 
   206 		TPtrC8 memBuf(ptrPos,readBuf.Length());
 
   200 		test(memBuf==readBuf);
 
   207 		test(memBuf==readBuf);
 
   201 
   208 
   202 		ptrPos+=9913;
 
   209 		ptrPos+=9913;
 
   203 		pos=9913;
 
   210 		pos=9913;
 
   204 		r=f.Seek(ESeekStart,pos);
 
   211 		r=f.Seek(ESeekStart,pos);
 
   205 		test(r==KErrNone);
 
   212 		test_KErrNone(r);
 
   206 		readBuf.SetLength(0);
 
   213 		readBuf.SetLength(0);
 
   207 		r=f.Read(readBuf);
 
   214 		r=f.Read(readBuf);
 
   208 		test(r==KErrNone);
 
   215 		test_KErrNone(r);
 
   209 		test(readBuf.Length()==readBuf.MaxLength());
 
   216 		test(readBuf.Length()==readBuf.MaxLength());
 
   210 		memBuf.Set(ptrPos,readBuf.Length());
 
   217 		memBuf.Set(ptrPos,readBuf.Length());
 
   211 		test(memBuf==readBuf);
 
   218 		test(memBuf==readBuf);
 
   212 
   219 
   213 		RFile f2;
 
   220 		RFile f2;
 
   214 		pos=10;
 
   221 		pos=10;
 
   215 		r=f2.Open(TheFs,KTFsrvCpp,EFileRead);
 
   222 		r=f2.Open(TheFs,KTFsrvCpp,EFileRead);
 
   216 
   223 
   217 		test(r==KErrNone);
 
   224 		test_KErrNone(r);
 
   218 		r=f2.Seek(ESeekAddress,pos);
 
   225 		r=f2.Seek(ESeekAddress,pos);
 
   219 		ptrPos=*(TText8**)&pos;
 
   226 		ptrPos=*(TText8**)&pos;
 
   220 		test(r==KErrNone);
 
   227 		test_KErrNone(r);
 
   221 		readBuf.SetLength(0);
 
   228 		readBuf.SetLength(0);
 
   222 		pos=10;
 
   229 		pos=10;
 
   223 		r=f2.Seek(ESeekStart,pos);
 
   230 		r=f2.Seek(ESeekStart,pos);
 
   224 		test(r==KErrNone);
 
   231 		test_KErrNone(r);
 
   225 		r=f2.Read(readBuf);
 
   232 		r=f2.Read(readBuf);
 
   226 		test(r==KErrNone);
 
   233 		test_KErrNone(r);
 
   227 		test(readBuf.Length()==readBuf.MaxLength());
 
   234 		test(readBuf.Length()==readBuf.MaxLength());
 
   228 		memBuf.Set(ptrPos,readBuf.Length());
 
   235 		memBuf.Set(ptrPos,readBuf.Length());
 
   229 		test(memBuf==readBuf);
 
   236 		test(memBuf==readBuf);
 
   230 
   237 
   231 		ptrPos+=2445;
 
   238 		ptrPos+=2445;
 
   232 		pos=10+2445;
 
   239 		pos=10+2445;
 
   233 		r=f2.Seek(ESeekStart,pos);
 
   240 		r=f2.Seek(ESeekStart,pos);
 
   234 		test(r==KErrNone);
 
   241 		test_KErrNone(r);
 
   235 		readBuf.SetLength(0);
 
   242 		readBuf.SetLength(0);
 
   236 		r=f2.Read(readBuf);
 
   243 		r=f2.Read(readBuf);
 
   237 		test(r==KErrNone);
 
   244 		test_KErrNone(r);
 
   238 		test(readBuf.Length()==readBuf.MaxLength());
 
   245 		test(readBuf.Length()==readBuf.MaxLength());
 
   239 		memBuf.Set(ptrPos,readBuf.Length());
 
   246 		memBuf.Set(ptrPos,readBuf.Length());
 
   240 		test(memBuf==readBuf);
 
   247 		test(memBuf==readBuf);
 
   241 
   248 
   242 		pos=0;
 
   249 		pos=0;
 
   243 		r=f.Seek(ESeekAddress,pos);
 
   250 		r=f.Seek(ESeekAddress,pos);
 
   244 		ptrPos=*(TText8**)&pos;
 
   251 		ptrPos=*(TText8**)&pos;
 
   245 		test(r==KErrNone);
 
   252 		test_KErrNone(r);
 
   246 		readBuf.SetLength(0);
 
   253 		readBuf.SetLength(0);
 
   247 		pos=0;
 
   254 		pos=0;
 
   248 		r=f.Seek(ESeekStart,pos);
 
   255 		r=f.Seek(ESeekStart,pos);
 
   249 		test(r==KErrNone);
 
   256 		test_KErrNone(r);
 
   250 		r=f.Read(readBuf);
 
   257 		r=f.Read(readBuf);
 
   251 		test(r==KErrNone);
 
   258 		test_KErrNone(r);
 
   252 		test(readBuf.Length()==readBuf.MaxLength());
 
   259 		test(readBuf.Length()==readBuf.MaxLength());
 
   253 		memBuf.Set(ptrPos,readBuf.Length());
 
   260 		memBuf.Set(ptrPos,readBuf.Length());
 
   254 		test(memBuf==readBuf);
 
   261 		test(memBuf==readBuf);
 
   255 
   262 
   256 		ptrPos+=5245;
 
   263 		ptrPos+=5245;
 
   257 		pos=5245;
 
   264 		pos=5245;
 
   258 		r=f.Seek(ESeekStart,pos);
 
   265 		r=f.Seek(ESeekStart,pos);
 
   259 		test(r==KErrNone);
 
   266 		test_KErrNone(r);
 
   260 		readBuf.SetLength(0);
 
   267 		readBuf.SetLength(0);
 
   261 		r=f.Read(readBuf);
 
   268 		r=f.Read(readBuf);
 
   262 		test(r==KErrNone);
 
   269 		test_KErrNone(r);
 
   263 		test(readBuf.Length()==readBuf.MaxLength());
 
   270 		test(readBuf.Length()==readBuf.MaxLength());
 
   264 		memBuf.Set(ptrPos,readBuf.Length());
 
   271 		memBuf.Set(ptrPos,readBuf.Length());
 
   265 		test(memBuf==readBuf);
 
   272 		test(memBuf==readBuf);
 
   266 
   273 
   267 		f.Close();
 
   274 		f.Close();
 
   268 		f2.Close();
 
   275 		f2.Close();
 
   269 		}
 
   276 		}
 
   270 	}
 
   277 	}
 
   271 
   278 
   272 LOCAL_C void Test6()
 
   279 static void Test6()
 
   273 //
 
   280 //
 
   274 // Test rom return values
 
   281 // Test rom return values
 
   275 //
 
   282 //
 
   276 	{
 
   283 	{
 
   277 	test.Next(_L("Test rom return values"));
 
   284 	test.Next(_L("Test rom return values"));
 
   278 
   285 
   279 	RFile f;
 
   286 	RFile f;
 
   280 	TInt r=f.Replace(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead);
 
   287 	TInt r=f.Replace(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead);
 
   281 	test(r==KErrAccessDenied);
 
   288 	test_Value(r, r == KErrAccessDenied);
 
   282 	r=f.Create(TheFs,_L("Z:\\Test\\newT_Fsrv.Cpp"),EFileRead);
 
   289 	r=f.Create(TheFs,_L("Z:\\Test\\newT_Fsrv.Cpp"),EFileRead);
 
   283 	test(r==KErrAccessDenied);
 
   290 	test_Value(r, r == KErrAccessDenied);
 
   284 	r=f.Open(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead);
 
   291 	r=f.Open(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead);
 
   285 	test(r==KErrNone);
 
   292 	test_KErrNone(r);
 
   286 	f.Close();
 
   293 	f.Close();
 
   287 	r=f.Open(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead|EFileWrite);
 
   294 	r=f.Open(TheFs,_L("Z:\\Test\\T_Fsrv.Cpp"),EFileRead|EFileWrite);
 
   288 	test(r==KErrAccessDenied);
 
   295 	test_Value(r, r == KErrAccessDenied);
 
   289 	}
 
   296 	}
 
   290 
   297 
   291 LOCAL_C void Test7()
 
   298 static void Test7()
 
   292 //
 
   299 //
 
   293 // Test cache
 
   300 // Test cache
 
   294 //
 
   301 //
 
   295 	{
 
   302 	{
 
   296 
   303 
   300 	TBuf<32> file1=_L("\\TMISC\\CACHE.FILE");
 
   307 	TBuf<32> file1=_L("\\TMISC\\CACHE.FILE");
 
   301 	MakeFile(file1,uid1,contents1);
 
   308 	MakeFile(file1,uid1,contents1);
 
   302 
   309 
   303 	TEntry entry;
 
   310 	TEntry entry;
 
   304 	TInt r=TheFs.Entry(file1,entry);
 
   311 	TInt r=TheFs.Entry(file1,entry);
 
   305 	test(r==KErrNone);
 
   312 	test_KErrNone(r);
 
   306 	test(entry.iType==uid1);
 
   313 	test(entry.iType==uid1);
 
   307 
   314 
   308 	TUidType uid2(TUid::Uid(4),TUid::Uid(5),TUid::Uid(6));
 
   315 	TUidType uid2(TUid::Uid(4),TUid::Uid(5),TUid::Uid(6));
 
   309 	TCheckedUid checkedUid(uid2);
 
   316 	TCheckedUid checkedUid(uid2);
 
   310 	TPtrC8 uidData((TUint8*)&checkedUid,sizeof(TCheckedUid));
 
   317 	TPtrC8 uidData((TUint8*)&checkedUid,sizeof(TCheckedUid));
 
   311 	RFile f;
 
   318 	RFile f;
 
   312 	r=f.Open(TheFs,file1,EFileRead|EFileWrite);
 
   319 	r=f.Open(TheFs,file1,EFileRead|EFileWrite);
 
   313 	test(r==KErrNone);
 
   320 	test_KErrNone(r);
 
   314 	r=f.Write(uidData);
 
   321 	r=f.Write(uidData);
 
   315 	test(r==KErrNone);
 
   322 	test_KErrNone(r);
 
   316 	r = f.Flush();
 
   323 	r = f.Flush();
 
   317 	test(r==KErrNone);
 
   324 	test_KErrNone(r);
 
   318 
   325 
   319 	r=TheFs.Entry(file1,entry);
 
   326 	r=TheFs.Entry(file1,entry);
 
   320 	test(r==KErrNone);
 
   327 	test_KErrNone(r);
 
   321 	test(entry.iType==uid2);
 
   328 	test(entry.iType==uid2);
 
   322 
   329 
   323 	f.Close();
 
   330 	f.Close();
 
   324 	r=TheFs.Entry(file1,entry);
 
   331 	r=TheFs.Entry(file1,entry);
 
   325 	test(r==KErrNone);
 
   332 	test_KErrNone(r);
 
   326 	test(entry.iType==uid2);
 
   333 	test(entry.iType==uid2);
 
   327 	}
 
   334 	}
 
   328 
   335 
   329 LOCAL_C void Test8()
 
   336 static void Test8()
 
   330 //
 
   337 //
 
   331 // Test IsValidName
 
   338 // Test IsValidName
 
   332 //
 
   339 //
 
   333 	{
 
   340 	{
 
   334 	test.Next(_L("Test RFs::IsValidName(TDesC)"));
 
   341 	test.Next(_L("Test RFs::IsValidName(TDesC)"));
 
   533                 }
 
   540                 }
 
   534             }
 
   541             }
 
   535         }
 
   542         }
 
   536 	}
 
   543 	}
 
   537 
   544 
   538 LOCAL_C void Test9()
 
   545 static void Test9()
 
   539 //
 
   546 //
 
   540 // Test IsFileInRom
 
   547 // Test IsFileInRom
 
   541 //
 
   548 //
 
   542 	{
 
   549 	{
 
   543 
   550 
   544 	test.Next(_L("Test RFs::IsFileInRom"));
 
   551 	test.Next(_L("Test RFs::IsFileInRom"));
 
   545 
   552 
   546 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   553 	CFileMan* fMan=CFileMan::NewL(TheFs);
 
   547 	TInt r=fMan->Copy(_L("Z:\\TEST\\T_FILE.CPP"),_L("C:\\T_FILE.CPP"));
 
   554 	TInt r=fMan->Copy(_L("Z:\\TEST\\T_FILE.CPP"),_L("C:\\T_FILE.CPP"));
 
   548 	test(r==KErrNone || r==KErrAccessDenied);
 
   555 	test_Value(r, r == KErrNone || r==KErrAccessDenied);
 
   549 	delete fMan;
 
   556 	delete fMan;
 
   550 	TUint8* addr=TheFs.IsFileInRom(_L("C:\\ESHELL.EXE"));
 
   557 	TUint8* addr=TheFs.IsFileInRom(_L("C:\\ESHELL.EXE"));
 
   551 	test(addr==NULL);
 
   558 	test(addr==NULL);
 
   552 	addr=TheFs.IsFileInRom(_L("Z:\\TEST\\T_FILE.CPP"));
 
   559 	addr=TheFs.IsFileInRom(_L("Z:\\TEST\\T_FILE.CPP"));
 
   553 	if (addr!=NULL)
 
   560 	if (addr!=NULL)
 
   560 		{
 
   567 		{
 
   561 		test (addr==NULL);
 
   568 		test (addr==NULL);
 
   562 		}
 
   569 		}
 
   563 	}
 
   570 	}
 
   564 
   571 
   565 LOCAL_C void Test10()
 
   572 static void Test10()
 
   566 //
 
   573 //
 
   567 // Test drive names
 
   574 // Test drive names
 
   568 //
 
   575 //
 
   569 	{
 
   576 	{
 
   570 
   577 
   572 	TFileName driveName;
 
   579 	TFileName driveName;
 
   573 	TInt i;
 
   580 	TInt i;
 
   574 	for(i=0;i<KMaxDrives;i++)
 
   581 	for(i=0;i<KMaxDrives;i++)
 
   575 		{
 
   582 		{
 
   576 		TInt r=TheFs.GetDriveName(i,driveName);
 
   583 		TInt r=TheFs.GetDriveName(i,driveName);
 
   577 		test(r==KErrNone);
 
   584 		test_KErrNone(r);
 
   578 		if (driveName.Length())
 
   585 		if (driveName.Length())
 
   579 			test.Printf(_L("Default name of %c: == %S\n"),'A'+i,&driveName);
 
   586 			test.Printf(_L("Default name of %c: == %S\n"),'A'+i,&driveName);
 
   580 		}
 
   587 		}
 
   581 
   588 
   582 	TBuf<64> drive0=_L("Dilbert");
 
   589 	TBuf<64> drive0=_L("Dilbert");
 
   583 	TBuf<64> drive4=_L("Dogbert");
 
   590 	TBuf<64> drive4=_L("Dogbert");
 
   584 	TBuf<64> drive17=_L("Flibble");
 
   591 	TBuf<64> drive17=_L("Flibble");
 
   585 	TBuf<64> drive25=_L("RAMDRIVE");
 
   592 	TBuf<64> drive25=_L("RAMDRIVE");
 
   586 	TInt r=TheFs.SetDriveName(0,drive0);
 
   593 	TInt r=TheFs.SetDriveName(0,drive0);
 
   587 	test(r==KErrNone);
 
   594 	test_KErrNone(r);
 
   588 	r=TheFs.SetDriveName(4,drive4);
 
   595 	r=TheFs.SetDriveName(4,drive4);
 
   589 	test(r==KErrNone);
 
   596 	test_KErrNone(r);
 
   590 	r=TheFs.SetDriveName(17,drive17);
 
   597 	r=TheFs.SetDriveName(17,drive17);
 
   591 	test(r==KErrNone);
 
   598 	test_KErrNone(r);
 
   592 	r=TheFs.SetDriveName(25,drive25);
 
   599 	r=TheFs.SetDriveName(25,drive25);
 
   593 	test(r==KErrNone);
 
   600 	test_KErrNone(r);
 
   594 
   601 
   595 	r=TheFs.GetDriveName(0,driveName);
 
   602 	r=TheFs.GetDriveName(0,driveName);
 
   596 	test(r==KErrNone);
 
   603 	test_KErrNone(r);
 
   597 	test(driveName==drive0);
 
   604 	test(driveName==drive0);
 
   598 	r=TheFs.GetDriveName(4,driveName);
 
   605 	r=TheFs.GetDriveName(4,driveName);
 
   599 	test(r==KErrNone);
 
   606 	test_KErrNone(r);
 
   600 	test(driveName==drive4);
 
   607 	test(driveName==drive4);
 
   601 	r=TheFs.GetDriveName(17,driveName);
 
   608 	r=TheFs.GetDriveName(17,driveName);
 
   602 	test(r==KErrNone);
 
   609 	test_KErrNone(r);
 
   603 	test(driveName==drive17);
 
   610 	test(driveName==drive17);
 
   604 	r=TheFs.GetDriveName(25,driveName);
 
   611 	r=TheFs.GetDriveName(25,driveName);
 
   605 	test(r==KErrNone);
 
   612 	test_KErrNone(r);
 
   606 	test(driveName==drive25);
 
   613 	test(driveName==drive25);
 
   607 
   614 
   608 	drive0=_L("askdjflsdfourewoqiuroiuaksjdvx,cvsdhwjhjhalsjhfshfkjhslj");
 
   615 	drive0=_L("askdjflsdfourewoqiuroiuaksjdvx,cvsdhwjhjhalsjhfshfkjhslj");
 
   609 	r=TheFs.SetDriveName(0,drive0);
 
   616 	r=TheFs.SetDriveName(0,drive0);
 
   610 	test(r==KErrNone);
 
   617 	test_KErrNone(r);
 
   611 	r=TheFs.GetDriveName(0,driveName);
 
   618 	r=TheFs.GetDriveName(0,driveName);
 
   612 	test(r==KErrNone);
 
   619 	test_KErrNone(r);
 
   613 	test(driveName==drive0);
 
   620 	test(driveName==drive0);
 
   614 
   621 
   615 //	Test with illegal characters in drive name
 
   622 //	Test with illegal characters in drive name
 
   616 	drive0=_L("Dil>bert");
 
   623 	drive0=_L("Dil>bert");
 
   617 	drive4=_L("Dog?bert");
 
   624 	drive4=_L("Dog?bert");
 
   618 	drive17=_L("Fli*bble");
 
   625 	drive17=_L("Fli*bble");
 
   619 	drive25=_L("RAMD//RIVE");
 
   626 	drive25=_L("RAMD//RIVE");
 
   620 
   627 
   621 	r=TheFs.SetDriveName(0,drive0);
 
   628 	r=TheFs.SetDriveName(0,drive0);
 
   622 	test(r==KErrBadName);
 
   629 	test_Value(r, r == KErrBadName);
 
   623 	r=TheFs.SetDriveName(4,drive4);
 
   630 	r=TheFs.SetDriveName(4,drive4);
 
   624 	test(r==KErrBadName);
 
   631 	test_Value(r, r == KErrBadName);
 
   625 	r=TheFs.SetDriveName(17,drive17);
 
   632 	r=TheFs.SetDriveName(17,drive17);
 
   626 	test(r==KErrBadName);
 
   633 	test_Value(r, r == KErrBadName);
 
   627 	r=TheFs.SetDriveName(25,drive25);
 
   634 	r=TheFs.SetDriveName(25,drive25);
 
   628 	test(r==KErrBadName);
 
   635 	test_Value(r, r == KErrBadName);
 
   629 
   636 
   630 //	Test that it is OK to set the name to no characters
 
   637 //	Test that it is OK to set the name to no characters
 
   631 
   638 
   632 	drive0=_L("");
 
   639 	drive0=_L("");
 
   633 	drive4=_L("");
 
   640 	drive4=_L("");
 
   634 	drive17=_L("");
 
   641 	drive17=_L("");
 
   635 	drive25=_L("");
 
   642 	drive25=_L("");
 
   636 
   643 
   637 	r=TheFs.SetDriveName(0,drive0);
 
   644 	r=TheFs.SetDriveName(0,drive0);
 
   638 	test(r==KErrNone);
 
   645 	test_KErrNone(r);
 
   639 	r=TheFs.SetDriveName(4,drive4);
 
   646 	r=TheFs.SetDriveName(4,drive4);
 
   640 	test(r==KErrNone);
 
   647 	test_KErrNone(r);
 
   641 	r=TheFs.SetDriveName(17,drive17);
 
   648 	r=TheFs.SetDriveName(17,drive17);
 
   642 	test(r==KErrNone);
 
   649 	test_KErrNone(r);
 
   643 	r=TheFs.SetDriveName(25,drive25);
 
   650 	r=TheFs.SetDriveName(25,drive25);
 
   644 	test(r==KErrNone);
 
   651 	test_KErrNone(r);
 
   645 
   652 
   646 	r=TheFs.GetDriveName(0,driveName);
 
   653 	r=TheFs.GetDriveName(0,driveName);
 
   647 	test(r==KErrNone);
 
   654 	test_KErrNone(r);
 
   648 	test(driveName==drive0);
 
   655 	test(driveName==drive0);
 
   649 	r=TheFs.GetDriveName(4,driveName);
 
   656 	r=TheFs.GetDriveName(4,driveName);
 
   650 	test(r==KErrNone);
 
   657 	test_KErrNone(r);
 
   651 	test(driveName==drive4);
 
   658 	test(driveName==drive4);
 
   652 	r=TheFs.GetDriveName(17,driveName);
 
   659 	r=TheFs.GetDriveName(17,driveName);
 
   653 	test(r==KErrNone);
 
   660 	test_KErrNone(r);
 
   654 	test(driveName==drive17);
 
   661 	test(driveName==drive17);
 
   655 	r=TheFs.GetDriveName(25,driveName);
 
   662 	r=TheFs.GetDriveName(25,driveName);
 
   656 	test(r==KErrNone);
 
   663 	test_KErrNone(r);
 
   657 	test(driveName==drive25);
 
   664 	test(driveName==drive25);
 
   658 
   665 
   659 
   666 
   660 	}
 
   667 	}
 
   661 
   668 
   662 LOCAL_C void Test11()
 
   669 static void Test11()
 
   663 //
 
   670 //
 
   664 // Miscellaneous tests
 
   671 // Miscellaneous tests
 
   665 //
 
   672 //
 
   666 	{
 
   673 	{
 
   667 
   674 
   668 	test.Next(_L("Miscellaneous tests"));
 
   675 	test.Next(_L("Miscellaneous tests"));
 
   669 	TVolumeInfo vol;
 
   676 	TVolumeInfo vol;
 
   670 	TInt r=TheFs.Volume(vol);
 
   677 	TInt r=TheFs.Volume(vol);
 
   671 	test.Printf(_L("VolumeName = %S\n"),&vol.iName);
 
   678 	test.Printf(_L("VolumeName = %S\n"),&vol.iName);
 
   672 	test(r==KErrNone);
 
   679 	test_KErrNone(r);
 
   673 	r=TheFs.RmDir(_L("\\asdfasdf.\\"));
 
   680 	r=TheFs.RmDir(_L("\\asdfasdf.\\"));
 
   674 	test(r==KErrBadName);
 
   681 	test_Value(r, r == KErrBadName);
 
   675 	r=TheFs.MkDir(_L("\\asdfasdf.\\"));
 
   682 	r=TheFs.MkDir(_L("\\asdfasdf.\\"));
 
   676 	test(r==KErrBadName);
 
   683 	test_Value(r, r == KErrBadName);
 
   677 	}
 
   684 	}
 
   678 
   685 
   679 LOCAL_C void Test12()
 
   686 static void Test12()
 
   680 //
 
   687 //
 
   681 // Test SetNotifyUser and GetNotifyUser
 
   688 // Test SetNotifyUser and GetNotifyUser
 
   682 //
 
   689 //
 
   683 	{
 
   690 	{
 
   684 
   691 
   693 	TheFs.SetNotifyUser(notifyState);
 
   700 	TheFs.SetNotifyUser(notifyState);
 
   694 	notifyState=TheFs.GetNotifyUser();
 
   701 	notifyState=TheFs.GetNotifyUser();
 
   695 	test(notifyState);
 
   702 	test(notifyState);
 
   696 	}
 
   703 	}
 
   697 
   704 
   698 LOCAL_C void Test13()
 
   705 static void Test13()
 
   699 //
 
   706 //
 
   700 // Test return values from RFs::Volume on cf-cards
 
   707 // Test return values from RFs::Volume on cf-cards
 
   701 //
 
   708 //
 
   702 	{
 
   709 	{
 
   703 
   710 
   704 	test.Next(_L("Test RFs::Volume"));
 
   711 	test.Next(_L("Test RFs::Volume"));
 
   705 	TVolumeInfo vol;
 
   712 	TVolumeInfo vol;
 
   706 	TInt r=TheFs.Volume(vol,EDriveB);
 
   713 	TInt r=TheFs.Volume(vol,EDriveB);
 
   707 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   714 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   708 	test.Printf(_L("RFs::Volume EDriveB returned %d\n"),r);
 
   715 	test.Printf(_L("RFs::Volume EDriveB returned %d\n"),r);
 
   709 
   716 
   710 	r=TheFs.Volume(vol,EDriveC);
 
   717 	r=TheFs.Volume(vol,EDriveC);
 
   711 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   718 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   712 	test.Printf(_L("RFs::Volume EDriveC returned %d\n"),r);
 
   719 	test.Printf(_L("RFs::Volume EDriveC returned %d\n"),r);
 
   713 
   720 
   714 	r=TheFs.Volume(vol,EDriveD);
 
   721 	r=TheFs.Volume(vol,EDriveD);
 
   715 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   722 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   716 	test.Printf(_L("RFs::Volume EDriveD returned %d\n"),r);
 
   723 	test.Printf(_L("RFs::Volume EDriveD returned %d\n"),r);
 
   717 
   724 
   718 	r=TheFs.Volume(vol,EDriveE);
 
   725 	r=TheFs.Volume(vol,EDriveE);
 
   719 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   726 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   720 	test.Printf(_L("RFs::Volume EDriveE returned %d\n"),r);
 
   727 	test.Printf(_L("RFs::Volume EDriveE returned %d\n"),r);
 
   721 
   728 
   722 	r=TheFs.Volume(vol,EDriveF);
 
   729 	r=TheFs.Volume(vol,EDriveF);
 
   723 	test(r==KErrNotReady || r==KErrNone || KErrPathNotFound);
 
   730 	test_Value(r, r == KErrNotReady || r==KErrNone || r == KErrPathNotFound);
 
   724 	test.Printf(_L("RFs::Volume EDriveF returned %d\n"),r);
 
   731 	test.Printf(_L("RFs::Volume EDriveF returned %d\n"),r);
 
   725 	}
 
   732 	}
 
   726 
   733 
   727 
   734 
   728 void    DoTest14(TInt aDrvNum);
 
   735 void    DoTest14(TInt aDrvNum);
 
   729 TInt    CreateStuffedFile(RFs& aFs, const TDesC& aFileName, TUint aFileSize);
 
   736 TInt    CreateStuffedFile(RFs& aFs, const TDesC& aFileName, TUint aFileSize);
 
   730 TInt    CreateEmptyFile(RFs& aFs, const TDesC& aFileName, TUint aFileSize);
 
       
   731 TBool   CheckFileContents(RFs& aFs, const TDesC& aFileName);
 
   737 TBool   CheckFileContents(RFs& aFs, const TDesC& aFileName);
 
   732 #ifndef __NFE_MEDIA_DRIVER_PRESENT__
 
   738 #ifndef __NFE_MEDIA_DRIVER_PRESENT__
 
   733 TBool   CheckBufferContents(const TDesC8& aBuffer, TUint aPrintBaseAddr=0);
 
   739 TBool   CheckBufferContents(const TDesC8& aBuffer, TUint aPrintBaseAddr=0);
 
   734 #endif
 
   740 #endif
 
   735 
   741 
   736 /**
 
   742 /**
 
   737 Testing unallocated data initialization vulnerability in RFile
 
   743     Testing unallocated data initialization vulnerability in RFile
 
   738 This test is performed on RAM drives and non-removable media that supports DeleteNotify (KMediaAttDeleteNotify flag)
 
   744     This test is performed on RAM drives and non-removable media that supports DeleteNotify (KMediaAttDeleteNotify flag)
 
   739 e.g. XSR NAND
 
   745     e.g. XSR NAND
 
   740 */
 
   746 */
 
   741 LOCAL_C void Test14()
 
   747 static void Test14()
 
   742 {
 
   748 {
 
   743 	TInt nRes;
 
       
   744 
   749 
   745 	test.Next(_L("Testing unallocated data initialization vulnerability in RFile"));
 
   750 	test.Next(_L("Testing unallocated data initialization vulnerability in RFile"));
 
   746 
   751 
   747 	TDriveList driveList;
 
   752     TDriveInfo driveInfo;
 
   748 	TDriveInfo driveInfo;
 
   753 	
   749 
   754     //-- get drive info
 
   750 	//-- 1. get drives list
 
   755 	test(TheFs.Drive(driveInfo, gDriveNum) == KErrNone);
 
   751 	nRes=TheFs.DriveList(driveList);
 
   756 
   752     test(nRes == KErrNone);
 
   757     const TBool bMediaSuitable = (driveInfo.iType == EMediaRam)     || //-- RAM drives should be tested
 
   753 
   758                                  (driveInfo.iType == EMediaFlash)   || //-- NOR FLASH drives should be tested
 
   754 	//-- 2. walk through all drives, performing the test only on suitable ones
 
   759                                  (driveInfo.iType == EMediaNANDFlash && driveInfo.iMediaAtt & KMediaAttDeleteNotify); //-- NAND media with DeleteNotify support
 
   755 	for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum)
 
   760     
       
   761     if(!bMediaSuitable)
 
   756     {
 
   762     {
 
   757 	    if(!driveList[drvNum])
 
   763         test.Printf(_L("This test can't be performed on this type of the media! Skipping.\n"));
 
   758 	        continue;   //-- skip unexisting drive
 
   764         return;
 
   759 
   765     }
 
   760 	    //-- get drive info
 
   766     
   761 	    test(TheFs.Drive(driveInfo, drvNum) == KErrNone);
 
   767     DoTest14(gDriveNum);
 
   762 
       
   763 	    //-- select a suitable drive for the testing. It shall be RAM drive, of FLASH but not removable
 
       
   764 	    //-- and not read only, if it is FLASH, it shall support "Delete Notify" facility
 
       
   765         switch(driveInfo.iType)
 
       
   766         {
 
       
   767         //-- RAM drive, OK
 
       
   768         case EMediaRam:
 
       
   769         break;
 
       
   770 
       
   771         //-- FLASH drive, OK
 
       
   772         case EMediaFlash:
 
       
   773         case EMediaNANDFlash:
 
       
   774             if(driveInfo.iMediaAtt & KMediaAttDeleteNotify)
 
       
   775                 break; //-- this type of media shall support DeleteNotify flag, otherwise this test is inconsistent
 
       
   776             else continue;
 
       
   777 
       
   778         //break; //unreacable
 
       
   779 
       
   780         default:
 
       
   781             continue;
 
       
   782         }//switch(driveInfo.iType)
 
       
   783 
       
   784 		if (driveInfo.iDriveAtt	& KDriveAttSubsted)
 
       
   785 			{
 
       
   786 			// skip subst drives.
 
       
   787 			continue;
 
       
   788 			}
 
       
   789 
       
   790         TBool readOnly = driveInfo.iMediaAtt & KMediaAttWriteProtected;
 
       
   791         if(readOnly)
 
       
   792             continue; //-- nothing to do, can't create any file etc.
 
       
   793 
       
   794         //-- skip test on the emulator's C: drive, doesn't make any sense because
 
       
   795         //-- in this case we deal with WIN32 API and filesystem.
 
       
   796         #ifdef __WINS__
 
       
   797         if(drvNum == 2)
 
       
   798         {
 
       
   799              test.Printf(_L("Skipping test on emulator's C: drive\n"));
 
       
   800              continue;
 
       
   801         }
 
       
   802         #endif
 
       
   803 
       
   804         DoTest14(drvNum);
 
       
   805 
       
   806     }// for (TInt drvNum=0; ...
 
       
   807 
       
   808 }
 
   768 }
 
   809 
   769 
   810 //--------------------------------------------------------
 
   770 //--------------------------------------------------------
 
   811 
   771 
   812 /**
 
   772 /**
 
   833     //==============================
 
   793     //==============================
 
   834     test.Printf(_L("Testing scenario 1\n"));
 
   794     test.Printf(_L("Testing scenario 1\n"));
 
   835 
   795 
   836     //-- 1. create an empty file
 
   796     //-- 1. create an empty file
 
   837     nRes = CreateEmptyFile(TheFs, fileName, KFileSize);
 
   797     nRes = CreateEmptyFile(TheFs, fileName, KFileSize);
 
   838     test(nRes == KErrNone);
 
   798     test_KErrNone(nRes);
 
   839 
   799 
   840 #ifndef __NFE_MEDIA_DRIVER_PRESENT__	// can't easily check for illegitimate information if drive is encrypted
 
   800 #ifndef __NFE_MEDIA_DRIVER_PRESENT__	// can't easily check for illegitimate information if drive is encrypted
 
   841     //-- 1.1  check that this file doesn't contain illegitimate information.
 
   801     //-- 1.1  check that this file doesn't contain illegitimate information.
 
   842     nRes = CheckFileContents(TheFs, fileName);
 
   802     nRes = CheckFileContents(TheFs, fileName);
 
   843     test(nRes == KErrNone);
 
   803     test_KErrNone(nRes);
 
   844 #endif
 
   804 #endif
 
   845 
   805 
   846     //-- 1.2 delete the empty file
 
   806     //-- 1.2 delete the empty file
 
   847     nRes = TheFs.Delete(fileName);
 
   807     nRes = TheFs.Delete(fileName);
 
   848     test(nRes == KErrNone);
 
   808     test_KErrNone(nRes);
 
   849 
   809 
   850     //==============================
 
   810     //==============================
 
   851     //== Scenario 2.
 
   811     //== Scenario 2.
 
   852     //== Create file, filling it with some pattern.
 
   812     //== Create file, filling it with some pattern.
 
   853     //== Delete this file, FreeClusterListL() will be involved.
 
   813     //== Delete this file, FreeClusterListL() will be involved.
 
   856     //==============================
 
   816     //==============================
 
   857     test.Printf(_L("Testing scenario 2\n"));
 
   817     test.Printf(_L("Testing scenario 2\n"));
 
   858 
   818 
   859     //-- 2. create file filled with some data pattern
 
   819     //-- 2. create file filled with some data pattern
 
   860     nRes = CreateStuffedFile(TheFs, fileName, KFileSize);
 
   820     nRes = CreateStuffedFile(TheFs, fileName, KFileSize);
 
   861     test(nRes == KErrNone);
 
   821     test_KErrNone(nRes);
 
   862 
   822 
   863     //-- 2.1 delete this file
 
   823     //-- 2.1 delete this file
 
   864     TheFs.Delete(fileName);
 
   824     TheFs.Delete(fileName);
 
   865 
   825 
   866     //-- 2.1 create an empty file on the place of just deleted one (hopefully)
 
   826     //-- 2.1 create an empty file on the place of just deleted one (hopefully)
 
   867     nRes = CreateEmptyFile(TheFs, fileName, KFileSize);
 
   827     nRes = CreateEmptyFile(TheFs, fileName, KFileSize);
 
   868     test(nRes == KErrNone);
 
   828     test_KErrNone(nRes);
 
   869 
   829 
   870     //-- 2.2  check that this file doesn't contain illegitimate information.
 
   830     //-- 2.2  check that this file doesn't contain illegitimate information.
 
   871     nRes = CheckFileContents(TheFs, fileName);
 
   831     nRes = CheckFileContents(TheFs, fileName);
 
   872     test(nRes == KErrNone);
 
   832     test_KErrNone(nRes);
 
   873 
   833 
   874     //-- 2.3 delete this file
 
   834     //-- 2.3 delete this file
 
   875     TheFs.Delete(fileName);
 
   835     TheFs.Delete(fileName);
 
   876 
   836 
   877 }
 
   837 }
 
   878 
   838 
   879 LOCAL_C void Test15()
 
   839 static void Test15()
 
   880 //
 
   840 //
 
   881 // Test IsValidName
 
   841 // Test IsValidName
 
   882 //
 
   842 //
 
   883 	{
 
   843 	{
 
   884 	test.Next(_L("Test RFs::IsValidName(TDesC& ,RFs::TNameValidParam& )"));
 
   844 	test.Next(_L("Test RFs::IsValidName(TDesC& ,RFs::TNameValidParam& )"));
 
  1171 void TestGetMediaSerialNumber()
 
  1131 void TestGetMediaSerialNumber()
 
  1172     {
 
  1132     {
 
  1173 	test.Next(_L("Test RFs::GetMediaSerialNumber"));	
  1133 	test.Next(_L("Test RFs::GetMediaSerialNumber"));	
  1174     TInt theDrive;
 
  1134     TInt theDrive;
 
  1175     TInt r = TheFs.CharToDrive(gDriveToTest,theDrive);
 
  1135     TInt r = TheFs.CharToDrive(gDriveToTest,theDrive);
 
  1176     test(r == KErrNone);
 
  1136     test_KErrNone(r);
 
  1177     TMediaSerialNumber serNum;
 
  1137     TMediaSerialNumber serNum;
 
  1178     r = TheFs.GetMediaSerialNumber(serNum, theDrive);
 
  1138     r = TheFs.GetMediaSerialNumber(serNum, theDrive);
 
  1179 	if (r) test.Printf(_L("RFs::GetMediaSerialNumber returned error %d"), r);
 
  1139 	if (r) test.Printf(_L("RFs::GetMediaSerialNumber returned error %d"), r);
 
  1180     test(r == KErrNotSupported || r == KErrNotReady || r == KErrNone);
 
  1140     test_Value(r, r == KErrNotSupported || r == KErrNotReady || r == KErrNone);
 
  1181     if (r == KErrNotSupported)
 
  1141     if (r == KErrNotSupported)
 
  1182         {
 
  1142         {
 
  1183         test.Printf(_L("MediaSerialNumber: Not Supported\n"));
 
  1143         test.Printf(_L("MediaSerialNumber: Not Supported\n"));
 
  1184         }
 
  1144         }
 
  1185     else
 
  1145     else
 
  1207     }
 
  1167     }
 
  1208 
  1168 
  1209 
  1169 
  1210 //--------------------------------------------------------
 
  1170 //--------------------------------------------------------
 
  1211 
  1171 
  1212 /**
 
       
  1213     Create an empty file of specified size.
 
       
  1214     @param  aFs		    ref. to the FS
 
       
  1215     @param  aFileName   name of the file
 
       
  1216     @param  aFileSize   size of the file to be created
 
       
  1217     @return    KErrNone on success, system-wide error code otherwise
 
       
  1218 */
 
       
  1219 TInt CreateEmptyFile(RFs& aFs, const TDesC& aFileName, TUint aFileSize)
 
       
  1220 {
 
       
  1221     RFile   file;
 
       
  1222 	TInt    nRes;
 
       
  1223 
       
  1224 	nRes = file.Create(aFs, aFileName, EFileRead|EFileWrite);
 
       
  1225     if(nRes != KErrNone)
 
       
  1226         return nRes;
 
       
  1227 
       
  1228 	nRes = file.SetSize(aFileSize);
 
       
  1229     if(nRes != KErrNone)
 
       
  1230         return nRes;
 
       
  1231 
       
  1232     file.Close();
 
       
  1233 
       
  1234     return KErrNone;
 
       
  1235 }
 
       
  1236 
       
  1237 //--------------------------------------------------------
 
       
  1238 
  1172 
  1239 /**
 
  1173 /**
 
  1240     Create a file of specified size filled with some data pattern.
 
  1174     Create a file of specified size filled with some data pattern.
 
  1241     @param  aFs		    ref. to the FS
 
  1175     @param  aFs		    ref. to the FS
 
  1242     @param  aFileName   name of the file
 
  1176     @param  aFileName   name of the file
 
  1302 	TBuf8<KBufLength> buffer;
 
  1236 	TBuf8<KBufLength> buffer;
 
  1303     buffer.SetLength(0);
 
  1237     buffer.SetLength(0);
 
  1304 
  1238 
  1305     //-- open the file
 
  1239     //-- open the file
 
  1306     nRes = file.Open(aFs, aFileName, EFileRead);
 
  1240     nRes = file.Open(aFs, aFileName, EFileRead);
 
  1307     test(nRes == KErrNone);
 
  1241     test_KErrNone(nRes);
 
  1308 
  1242 
  1309     //-- check file contents
 
  1243     //-- check file contents
 
  1310     TUint nFilePos=0;
 
  1244     TUint nFilePos=0;
 
  1311     for(;;)
 
  1245     for(;;)
 
  1312     {
 
  1246     {
 
  1313         //-- read data from the file into the buffer
 
  1247         //-- read data from the file into the buffer
 
  1314         nRes = file.Read(buffer);
 
  1248         nRes = file.Read(buffer);
 
  1315         test(nRes == KErrNone);
 
  1249         test_KErrNone(nRes);
 
  1316 
  1250 
  1317         if(buffer.Length() == 0)
 
  1251         if(buffer.Length() == 0)
 
  1318         {
 
  1252         {
 
  1319             nRes = KErrNone; //-- read all the file, no illegitimate information found
 
  1253             nRes = KErrNone; //-- read all the file, no illegitimate information found
 
  1320             break; //EOF
 
  1254             break; //EOF
 
  1361 {
 
  1295 {
 
  1362     TBool bRes = ETrue;
 
  1296     TBool bRes = ETrue;
 
  1363 
  1297 
  1364     //-- check if the buffer filled with allowable data (RAM page initialisation data or something similar)
 
  1298     //-- check if the buffer filled with allowable data (RAM page initialisation data or something similar)
 
  1365     //-- but not something meaningful.
 
  1299     //-- but not something meaningful.
 
  1366     //-- allowable bytes: 0x00, 0x03, 0xff, 0xcc
 
  1300     //-- Actually, the buffer should be filled with uniformed bytes (most probably, 0x00)
 
  1367     for(TInt i=0; i<aBuffer.Size(); ++i)
 
  1301     for(TInt i=0; i<aBuffer.Size(); ++i)
 
  1368     {
 
  1302     {
 
  1369         TUint8 byte = aBuffer[i];
 
  1303         TUint8 byte = aBuffer[i];
 
  1370         if(byte != 0x00 && byte != 0x03 && byte != 0xff && byte != 0xcc )
 
  1304         if(byte != aBuffer[0])
 
  1371         {
 
  1305         {
 
  1372             bRes = EFalse;
 
  1306             bRes = EFalse;
 
  1373             break;
 
  1307             break;
 
  1374         }
 
  1308         }
 
  1375     }
 
  1309     }
 
  1392 	}
 
  1326 	}
 
  1393 
  1327 
  1394     return bRes;
 
  1328     return bRes;
 
  1395 }
 
  1329 }
 
  1396 
  1330 
  1397 
  1331 //--------------------------------------------------------
 
  1398 GLDEF_C void CallTestsL()
 
  1332 /**
 
  1399 //
 
  1333     Check if the drive aDriveNo is finalised or not.
 
  1400 // Call tests that may leave
 
  1334     The "CleanShutDown" is obtained by QueryVolumeInfoExt API which is FS-agnostic.
 
  1401 //
 
  1335 
       
  1336     @param  aDriveNo drive number to query.
 
       
  1337     @return ETrue if the drive if finalised
 
       
  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()
 
  1402 	{
 
  1683 	{
 
  1403 
  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();
 
  1404 	Test1();
 
  1693 	Test1();
 
  1405 	Test2();
 
  1694 	Test2();
 
  1406 	Test3();
 
  1695 	Test3();
 
  1407 	Test4();
 
  1696 	Test4();
 
  1408 	Test5();
 
  1697 	Test5();
 
  1415 	Test12();
 
  1704 	Test12();
 
  1416 	Test13();
 
  1705 	Test13();
 
  1417 	Test14();
 
  1706 	Test14();
 
  1418 	Test15();
 
  1707 	Test15();
 
  1419     TestGetMediaSerialNumber();
 
  1708     TestGetMediaSerialNumber();
 
       
  1709 
  1420 	}
 
  1710 	}
MCL/sf/os/kernelhwsrv