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 |
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; |
|
748 TDriveInfo driveInfo; |
752 TDriveInfo driveInfo; |
749 |
753 |
750 //-- 1. get drives list |
754 //-- get drive info |
751 nRes=TheFs.DriveList(driveList); |
755 test(TheFs.Drive(driveInfo, gDriveNum) == KErrNone); |
752 test(nRes == KErrNone); |
756 |
753 |
757 const TBool bMediaSuitable = (driveInfo.iType == EMediaRam) || //-- RAM drives should be tested |
754 //-- 2. walk through all drives, performing the test only on suitable ones |
758 (driveInfo.iType == EMediaFlash) || //-- NOR FLASH drives should be tested |
755 for (TInt drvNum=0; drvNum<KMaxDrives; ++drvNum) |
759 (driveInfo.iType == EMediaNANDFlash && driveInfo.iMediaAtt & KMediaAttDeleteNotify); //-- NAND media with DeleteNotify support |
|
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 /** |
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(); |