0
|
1 |
// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
2 |
// All rights reserved.
|
|
3 |
// This component and the accompanying materials are made available
|
|
4 |
// under the terms of the License "Eclipse Public License v1.0"
|
|
5 |
// which accompanies this distribution, and is available
|
|
6 |
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
7 |
//
|
|
8 |
// Initial Contributors:
|
|
9 |
// Nokia Corporation - initial contribution.
|
|
10 |
//
|
|
11 |
// Contributors:
|
|
12 |
//
|
|
13 |
// Description:
|
|
14 |
// f32test\fsstress\t_remses.cpp
|
|
15 |
//
|
|
16 |
//
|
|
17 |
|
|
18 |
#if !defined(__T_REMFSY_H__)
|
|
19 |
#include "t_remfsy.h"
|
|
20 |
#endif
|
|
21 |
|
|
22 |
GLDEF_D TFileName tPath;
|
|
23 |
|
|
24 |
LOCAL_C void printDriveAtt(TInt aDrive,TUint anAtt,RTest& aTest);
|
|
25 |
LOCAL_C void printDriveInfo(TInt aDrive,TDriveInfo& anInfo, RTest& aTest);
|
|
26 |
LOCAL_C void DriveInformation(TInt aDrive,TDriveInfo& anInfo,RTest& aTest);
|
|
27 |
|
|
28 |
|
|
29 |
void TMultipleSessionTest::Initialise(RFs& aFs)
|
|
30 |
//
|
|
31 |
// Initialise iFs
|
|
32 |
//
|
|
33 |
{
|
|
34 |
iFs=aFs;
|
|
35 |
}
|
|
36 |
|
|
37 |
|
|
38 |
void TMultipleSessionTest::SetSessionPath(TInt aDrive)
|
|
39 |
//
|
|
40 |
// Set the session path for a RFs connection to aDrive
|
|
41 |
//
|
|
42 |
{
|
|
43 |
iSessionPath=(_L("?:\\MULTIPLE_SESSION_TEST\\"));
|
|
44 |
TChar driveLetter;
|
|
45 |
TInt r=iFs.DriveToChar(aDrive,driveLetter);
|
|
46 |
test(r==KErrNone);
|
|
47 |
|
|
48 |
iSessionPath[0]=(TText)driveLetter;
|
|
49 |
r=iFs.SetSessionPath(iSessionPath);
|
|
50 |
test(r==KErrNone);
|
|
51 |
r=iFs.MkDirAll(iSessionPath);
|
|
52 |
test(r==KErrNone || r==KErrAlreadyExists);
|
|
53 |
}
|
|
54 |
|
|
55 |
|
|
56 |
void TMultipleSessionTest::RunTests(RTest& aTest)
|
|
57 |
//
|
|
58 |
// Run tests on iFs file server session
|
|
59 |
//
|
|
60 |
|
|
61 |
{
|
|
62 |
|
|
63 |
testDriveList(aTest);
|
|
64 |
testDriveInfo(aTest);
|
|
65 |
testVolumeInfo(aTest);
|
|
66 |
// testPowerDown(aTest);
|
|
67 |
testSetVolume(aTest);
|
|
68 |
testInitialisation(aTest);
|
|
69 |
// testMediaChange(aTest);
|
|
70 |
testSubst(aTest);
|
|
71 |
MakeAndDeleteFiles(aTest);
|
|
72 |
}
|
|
73 |
|
|
74 |
|
|
75 |
|
|
76 |
void TMultipleSessionTest::testDriveList(RTest& aTest)
|
|
77 |
//
|
|
78 |
// Test the drive list.
|
|
79 |
//
|
|
80 |
{
|
|
81 |
|
|
82 |
aTest.Next(_L("The drive list"));
|
|
83 |
TInt r=iFs.SetSessionPath(iSessionPath);
|
|
84 |
TDriveList list;
|
|
85 |
r=iFs.DriveList(list);
|
|
86 |
aTest(r==KErrNone);
|
|
87 |
|
|
88 |
for (TInt i=0;i<KMaxDrives;i++)
|
|
89 |
{
|
|
90 |
TInt att=list[i];
|
|
91 |
if (att)
|
|
92 |
printDriveAtt(i,att,aTest);
|
|
93 |
}
|
|
94 |
}
|
|
95 |
|
|
96 |
void TMultipleSessionTest::testDriveInfo(RTest& aTest)
|
|
97 |
//
|
|
98 |
// Test the drive info.
|
|
99 |
//
|
|
100 |
{
|
|
101 |
|
|
102 |
aTest.Next(_L("The drive info"));
|
|
103 |
TInt r=iFs.SetSessionPath(iSessionPath);
|
|
104 |
TDriveList list;
|
|
105 |
r=iFs.DriveList(list);
|
|
106 |
aTest(r==KErrNone);
|
|
107 |
for (TInt i=0;i<KMaxDrives;i++)
|
|
108 |
{
|
|
109 |
TInt att=list[i];
|
|
110 |
if (att)
|
|
111 |
{
|
|
112 |
TDriveInfo d;
|
|
113 |
r=iFs.Drive(d,i);
|
|
114 |
//aTest(r==KErrNone);
|
|
115 |
printDriveInfo(i,d,aTest);
|
|
116 |
aTest.Printf(_L("\n"));
|
|
117 |
if (r==KErrNone)
|
|
118 |
DriveInformation(i,d, aTest);
|
|
119 |
}
|
|
120 |
}
|
|
121 |
}
|
|
122 |
/*
|
|
123 |
void TMultipleSessionTest::testPowerDown(RTest& aTest)
|
|
124 |
//
|
|
125 |
// Test the effect of multiple power downs
|
|
126 |
//
|
|
127 |
{
|
|
128 |
aTest.Next(_L("Power Down"));
|
|
129 |
|
|
130 |
RTimer timer;
|
|
131 |
test(timer.CreateLocal()==KErrNone);
|
|
132 |
TTime time;
|
|
133 |
TRequestStatus status;
|
|
134 |
|
|
135 |
for (TInt index=0; index<5; index++)
|
|
136 |
{
|
|
137 |
aTest.Printf(_L("********** %d **********\n"),(5-index));
|
|
138 |
time.HomeTime();
|
|
139 |
time+=TTimeIntervalSeconds(8);
|
|
140 |
timer.At(status,time);
|
|
141 |
UserHal::SwitchOff(); // Switch off
|
|
142 |
User::WaitForRequest(status); // Switch back on
|
|
143 |
aTest(status==KErrNone);
|
|
144 |
}
|
|
145 |
}
|
|
146 |
|
|
147 |
*/
|
|
148 |
/*
|
|
149 |
void TMultipleSessionTest::testMediaChange(RTest& aTest)
|
|
150 |
//
|
|
151 |
// Test the effect of multiple media changes
|
|
152 |
//
|
|
153 |
{
|
|
154 |
aTest.Next(_L("Media Change"));
|
|
155 |
TInt drive=CurrentDrive(aTest);
|
|
156 |
|
|
157 |
if (drive>KMaxLocalDrives)
|
|
158 |
return;
|
|
159 |
|
|
160 |
#if defined (__MARM__)
|
|
161 |
if (drive==EDriveC)
|
|
162 |
return;
|
|
163 |
#endif
|
|
164 |
|
|
165 |
TLocalDrive theDrive;
|
|
166 |
TLocalDriveCaps info;
|
|
167 |
TBool changedFlag;
|
|
168 |
for (TInt index=0; index<5; index++)
|
|
169 |
{
|
|
170 |
aTest.Printf(_L("********** %d **********\n"),(5-index));
|
|
171 |
changedFlag=EFalse;
|
|
172 |
TInt r=theDrive.Connect(drive,changedFlag);
|
|
173 |
aTest(r==KErrNone);
|
|
174 |
UserSvr::ForceRemountMedia(ERemovableMedia0); // Generate media change
|
|
175 |
aTest(changedFlag);
|
|
176 |
|
|
177 |
do
|
|
178 |
{
|
|
179 |
r=theDrive.Caps(info);
|
|
180 |
} while (r==KErrNotReady);
|
|
181 |
// Wait a second...
|
|
182 |
// User::After(1000000);
|
|
183 |
}
|
|
184 |
}
|
|
185 |
*/
|
|
186 |
|
|
187 |
void TMultipleSessionTest::testVolumeInfo(RTest& aTest)
|
|
188 |
//
|
|
189 |
// Test volume info.
|
|
190 |
//
|
|
191 |
{
|
|
192 |
|
|
193 |
aTest.Next(_L("The volume info"));
|
|
194 |
TInt r=iFs.SetSessionPath(iSessionPath);
|
|
195 |
TDriveList list;
|
|
196 |
r=iFs.DriveList(list);
|
|
197 |
aTest(r==KErrNone);
|
|
198 |
for (TInt i=0;i<KMaxDrives;i++)
|
|
199 |
{
|
|
200 |
TVolumeInfo v;
|
|
201 |
if ((r=iFs.Volume(v,i))==KErrNone)
|
|
202 |
{
|
|
203 |
printDriveInfo(i,v.iDrive,aTest);
|
|
204 |
aTest.Printf(_L(" VOL=\"%S\" ID=%08x\n"),&v.iName,v.iUniqueID);
|
|
205 |
aTest.Printf(_L(" SIZE=%ldK FREE=%ldK\n"),v.iSize/1024,v.iFree/1024);
|
|
206 |
}
|
|
207 |
else if (r==KErrNotReady)
|
|
208 |
aTest.Printf(_L("%c: Not Ready\n"),i+'A');
|
|
209 |
else if (r==KErrPathNotFound)
|
|
210 |
aTest.Printf(_L("%c: Not Found\n"),i+'A');
|
|
211 |
else
|
|
212 |
{
|
|
213 |
aTest.Printf(_L("%c: Error %d\n"),i+'A',r);
|
|
214 |
aTest.Getch();
|
|
215 |
}
|
|
216 |
aTest.Printf(_L("\n"));
|
|
217 |
}
|
|
218 |
}
|
|
219 |
|
|
220 |
|
|
221 |
void TMultipleSessionTest::testInitialisation(RTest& aTest)
|
|
222 |
//
|
|
223 |
// Modified from T_SESSION. Still tests that calls to CheckedClose() are
|
|
224 |
// OK, ie, tests bug fix, but doesn't check returned error values since remote drive
|
|
225 |
// doesn't necessarily return them.
|
|
226 |
//
|
|
227 |
{
|
|
228 |
RFile file;
|
|
229 |
RDir dir;
|
|
230 |
|
|
231 |
aTest.Next(_L("Test calls to CheckedClose are OK"));
|
|
232 |
|
|
233 |
TInt r=iFs.SetSessionPath(iSessionPath);
|
|
234 |
TInt count;
|
|
235 |
RFormat format;
|
|
236 |
r=format.Open(iFs,_L("Z:\\"),EFullFormat,count);
|
|
237 |
|
|
238 |
aTest((r==KErrAccessDenied)||(r==KErrInUse));
|
|
239 |
|
|
240 |
r=dir.Open(iFs,_L("\\MULTIPLE_SESSION_TEST\\ERRORTEST\\"),KEntryAttMatchMask);
|
|
241 |
// aTest(r==KErrPathNotFound);
|
|
242 |
if (r==KErrNone)
|
|
243 |
dir.Close();
|
|
244 |
|
|
245 |
r=file.Open(iFs,_L("\\MULTIPLE_SESSION_TEST\\SessionTest1.txt"),EFileRead);
|
|
246 |
// aTest(r==KErrNotFound);
|
|
247 |
if (r==KErrNone)
|
|
248 |
file.Close();
|
|
249 |
|
|
250 |
r=dir.Open(iFs,_L("\\MULTIPLE_SESSION_TEST\\ERRORTEST2\\"),KEntryAttMatchMask);
|
|
251 |
// aTest(r==KErrPathNotFound);
|
|
252 |
if (r==KErrNone)
|
|
253 |
dir.Close();
|
|
254 |
|
|
255 |
r=file.Open(iFs,_L("\\MULTIPLE_SESSION_TEST\\SessionTest2.txt"),EFileRead);
|
|
256 |
// aTest(r==KErrNotFound);
|
|
257 |
if (r==KErrNone)
|
|
258 |
file.Close();
|
|
259 |
|
|
260 |
r=dir.Open(iFs,_L("\\MULTIPLE_SESSION_TEST\\ERRORTEST3\\"),KEntryAttMatchMask);
|
|
261 |
// aTest(r==KErrPathNotFound);
|
|
262 |
if (r==KErrNone)
|
|
263 |
dir.Close();
|
|
264 |
|
|
265 |
r=file.Open(iFs,_L("\\MULTIPLE_SESSION_TEST\\SessionTest3.txt"),EFileRead);
|
|
266 |
// aTest(r==KErrNotFound);
|
|
267 |
if (r==KErrNone)
|
|
268 |
file.Close();
|
|
269 |
|
|
270 |
r=file.Open(iFs,_L("\\MULTIPLE_SESSION_TEST\\SessionTest4.txt"),EFileRead);
|
|
271 |
// aTest(r==KErrNotFound);
|
|
272 |
if (r==KErrNone)
|
|
273 |
file.Close();
|
|
274 |
}
|
|
275 |
|
|
276 |
|
|
277 |
void TMultipleSessionTest::testSubst(RTest& aTest)
|
|
278 |
//
|
|
279 |
// Test the substitute functions
|
|
280 |
//
|
|
281 |
{
|
|
282 |
|
|
283 |
aTest.Next(_L("Test subst"));
|
|
284 |
TInt r=iFs.SetSessionPath(iSessionPath);
|
|
285 |
TVolumeInfo v;
|
|
286 |
r=iFs.Volume(v);
|
|
287 |
aTest(r==KErrNone);
|
|
288 |
|
|
289 |
TDriveInfo driveInfo;
|
|
290 |
r=iFs.Drive(driveInfo,EDriveO);
|
|
291 |
aTest(r==KErrNone);
|
|
292 |
|
|
293 |
testSetVolume(aTest);
|
|
294 |
|
|
295 |
if (driveInfo.iDriveAtt==KDriveAttLocal)
|
|
296 |
return; // Subst local drives fails
|
|
297 |
|
|
298 |
TFileName n;
|
|
299 |
r=iFs.Subst(n,EDriveO);
|
|
300 |
aTest(r==KErrNone);
|
|
301 |
aTest(n.Length()==0);
|
|
302 |
r=iFs.SetSubst(iSessionPath,EDriveO);
|
|
303 |
aTest(r==KErrNone);
|
|
304 |
r=iFs.Subst(n,EDriveO);
|
|
305 |
aTest(r==KErrNone);
|
|
306 |
aTest(n==iSessionPath);
|
|
307 |
TVolumeInfo w;
|
|
308 |
r=iFs.Volume(w,EDriveO);
|
|
309 |
aTest(r==KErrNone);
|
|
310 |
aTest(w.iDrive.iType==v.iDrive.iType);
|
|
311 |
aTest(w.iDrive.iBattery==v.iDrive.iBattery);
|
|
312 |
aTest(w.iDrive.iDriveAtt==v.iDrive.iDriveAtt);
|
|
313 |
aTest(w.iDrive.iMediaAtt==v.iDrive.iMediaAtt);
|
|
314 |
aTest(w.iUniqueID==v.iUniqueID);
|
|
315 |
aTest(w.iSize==v.iSize);
|
|
316 |
aTest(w.iFree==v.iFree);
|
|
317 |
aTest(w.iName==v.iName);
|
|
318 |
TDriveInfo d;
|
|
319 |
r=iFs.Drive(d,EDriveO);
|
|
320 |
aTest(r==KErrNone);
|
|
321 |
aTest(d.iDriveAtt==KDriveAttSubsted);
|
|
322 |
|
|
323 |
aTest.Next(_L("Test real name"));
|
|
324 |
r=iFs.RealName(_L("O:\\FILE.XXX"),n);
|
|
325 |
aTest(r==KErrNone);
|
|
326 |
TFileName substedPath=iSessionPath;
|
|
327 |
substedPath.Append(_L("FILE.XXX"));
|
|
328 |
aTest(n==substedPath);
|
|
329 |
|
|
330 |
aTest.Next(_L("Test MkDir, Rename and RmDir on Substed drive"));
|
|
331 |
r=iFs.MkDir(_L("C:\\MULTIPLE_SESSION_TEST\\TFSRV\\turgid\\"));
|
|
332 |
aTest(r==KErrNone);
|
|
333 |
r=iFs.Rename(_L("O:\\turgid"), _L("O:\\facile"));
|
|
334 |
aTest(r==KErrNone);
|
|
335 |
r=iFs.MkDir(_L("O:\\insipid\\"));
|
|
336 |
aTest(r==KErrNone);
|
|
337 |
r=iFs.Rename(_L("O:\\insipid"), _L("O:\\glib"));
|
|
338 |
aTest(r==KErrNone);
|
|
339 |
r=iFs.RmDir(_L("O:\\facile\\"));
|
|
340 |
aTest(r==KErrNone);
|
|
341 |
r=iFs.RmDir(_L("C:\\MULTIPLE_SESSION_TEST\\TFSRV\\glib\\"));
|
|
342 |
aTest(r==KErrNone);
|
|
343 |
|
|
344 |
r=iFs.SetSubst(_L(""),EDriveO);
|
|
345 |
aTest(r==KErrNone);
|
|
346 |
r=iFs.Subst(n,EDriveO);
|
|
347 |
aTest(r==KErrNone);
|
|
348 |
aTest(n==_L(""));
|
|
349 |
r=iFs.Drive(d,EDriveO);
|
|
350 |
aTest(r==KErrNone);
|
|
351 |
aTest(d.iDriveAtt==0);
|
|
352 |
|
|
353 |
}
|
|
354 |
|
|
355 |
|
|
356 |
LOCAL_C TInt CreateFileX(const TDesC& aBaseName,TInt aX, RFs iFs, RTest& aTest)
|
|
357 |
//
|
|
358 |
// Create a large file. Return KErrEof or KErrNone
|
|
359 |
//
|
|
360 |
{
|
|
361 |
|
|
362 |
TBuf<128> fileName=aBaseName;
|
|
363 |
fileName.AppendNum(aX);
|
|
364 |
|
|
365 |
RFile file;
|
|
366 |
TInt r=file.Replace(iFs,fileName,EFileWrite);
|
|
367 |
if (r==KErrDiskFull)
|
|
368 |
return(r);
|
|
369 |
if (r!=KErrNone)
|
|
370 |
{
|
|
371 |
aTest.Printf(_L("ERROR:: Replace returned %d\n"),r);
|
|
372 |
aTest.Getch();
|
|
373 |
return(KErrDiskFull);
|
|
374 |
}
|
|
375 |
r=file.SetSize(65536);
|
|
376 |
if (r==KErrDiskFull)
|
|
377 |
{
|
|
378 |
file.Close();
|
|
379 |
return(r);
|
|
380 |
}
|
|
381 |
if (r!=KErrNone)
|
|
382 |
{
|
|
383 |
aTest.Printf(_L("ERROR:: SetSize returned %d\n"),r);
|
|
384 |
aTest.Getch();
|
|
385 |
file.Close();
|
|
386 |
return(KErrDiskFull);
|
|
387 |
}
|
|
388 |
file.Close();
|
|
389 |
aTest.Printf(_L("Created file %d size 64k\n"),aX);
|
|
390 |
return(KErrNone);
|
|
391 |
}
|
|
392 |
|
|
393 |
LOCAL_C TInt DeleteFileX(TBuf<128>& aBaseName,TInt aX, RFs iFs, TInt aDrive,RTest& aTest)
|
|
394 |
//
|
|
395 |
// Delete a file.
|
|
396 |
//
|
|
397 |
{
|
|
398 |
|
|
399 |
TBuf<128> fileName=aBaseName;
|
|
400 |
fileName.AppendNum(aX);
|
|
401 |
|
|
402 |
TInt r=iFs.Delete(fileName);
|
|
403 |
if (aDrive!=EDriveQ) // T_REMFSY may return incorrect value on WINS
|
|
404 |
aTest(r==KErrNone);
|
|
405 |
aTest.Printf(_L("Deleted File %d\n"),aX);
|
|
406 |
return(KErrNone);
|
|
407 |
}
|
|
408 |
|
|
409 |
void TMultipleSessionTest::MakeAndDeleteFiles(RTest& aTest)
|
|
410 |
//
|
|
411 |
// Create and delete large files in a randomish order
|
|
412 |
//
|
|
413 |
{
|
|
414 |
|
|
415 |
aTest.Next(_L("Create and delete large files"));
|
|
416 |
TInt r=iFs.SetSessionPath(iSessionPath);
|
|
417 |
r=iFs.MkDirAll(_L("\\MULTIPLE_SESSION_TEST\\SMALLDIRECTORY\\"));
|
|
418 |
|
|
419 |
if (CurrentDrive(aTest)!=EDriveQ) // T_REMFSY may return incorrect result on WINS
|
|
420 |
aTest(r==KErrNone || r==KErrAlreadyExists);
|
|
421 |
|
|
422 |
TBuf<128> fileName=_L("\\MULTIPLE_SESSION_TEST\\SMALLDIRECTORY\\FILE");
|
|
423 |
r=CreateFileX(fileName,0,iFs,aTest);
|
|
424 |
aTest(r==KErrNone);
|
|
425 |
r=CreateFileX(fileName,1,iFs,aTest);
|
|
426 |
aTest(r==KErrNone);
|
|
427 |
r=DeleteFileX(fileName,0,iFs,CurrentDrive(aTest),aTest);
|
|
428 |
aTest(r==KErrNone);
|
|
429 |
r=CreateFileX(fileName,2,iFs,aTest);
|
|
430 |
aTest(r==KErrNone);
|
|
431 |
r=CreateFileX(fileName,1,iFs,aTest);
|
|
432 |
aTest(r==KErrNone);
|
|
433 |
r=CreateFileX(fileName,3,iFs,aTest);
|
|
434 |
aTest(r==KErrNone);
|
|
435 |
r=DeleteFileX(fileName,1,iFs,CurrentDrive(aTest),aTest);
|
|
436 |
aTest(r==KErrNone);
|
|
437 |
r=CreateFileX(fileName,4,iFs,aTest);
|
|
438 |
aTest(r==KErrNone);
|
|
439 |
r=DeleteFileX(fileName,2,iFs,CurrentDrive(aTest),aTest);
|
|
440 |
aTest(r==KErrNone);
|
|
441 |
r=DeleteFileX(fileName,3,iFs,CurrentDrive(aTest),aTest);
|
|
442 |
aTest(r==KErrNone);
|
|
443 |
r=DeleteFileX(fileName,4,iFs,CurrentDrive(aTest),aTest);
|
|
444 |
aTest(r==KErrNone);
|
|
445 |
r=CreateFileX(fileName,1,iFs,aTest);
|
|
446 |
aTest(r==KErrNone);
|
|
447 |
r=DeleteFileX(fileName,1,iFs,CurrentDrive(aTest),aTest);
|
|
448 |
aTest(r==KErrNone);
|
|
449 |
|
|
450 |
r=iFs.CheckDisk(fileName);
|
|
451 |
if (r!=KErrNone && r!=KErrNotSupported)
|
|
452 |
aTest.Printf(_L("ERROR:: CheckDisk returned %d\n"),r);
|
|
453 |
}
|
|
454 |
|
|
455 |
void TMultipleSessionTest::FillUpDisk(RTest& aTest)
|
|
456 |
//
|
|
457 |
// Test that a full disk is ok
|
|
458 |
//
|
|
459 |
{
|
|
460 |
|
|
461 |
aTest.Next(_L("Fill disk to capacity"));
|
|
462 |
TInt r=iFs.SetSessionPath(iSessionPath);
|
|
463 |
r=iFs.MkDirAll(_L("\\MULTIPLE_SESSION_TEST\\BIGDIRECTORY\\"));
|
|
464 |
if (CurrentDrive(aTest)!=EDriveQ) // T_REMFSY may return incorrect result on WINS
|
|
465 |
aTest(r==KErrNone || r==KErrAlreadyExists);
|
|
466 |
TInt count=0;
|
|
467 |
TFileName sessionPath;
|
|
468 |
r=iFs.SessionPath(sessionPath);
|
|
469 |
test(sessionPath==iSessionPath);
|
|
470 |
aTest(r==KErrNone);
|
|
471 |
TBuf<128> fileName=_L("\\MULTIPLE_SESSION_TEST\\BIGDIRECTORY\\FILE");
|
|
472 |
FOREVER
|
|
473 |
{
|
|
474 |
TInt r=CreateFileX(fileName,count,iFs, aTest);
|
|
475 |
if (r==KErrDiskFull)
|
|
476 |
break;
|
|
477 |
aTest(r==KErrNone);
|
|
478 |
count++;
|
|
479 |
#if defined(__WINS__)
|
|
480 |
if (count==32 && sessionPath[0]=='C') // Don't fill up disk on NT
|
|
481 |
break;
|
|
482 |
#endif
|
|
483 |
}
|
|
484 |
|
|
485 |
r=iFs.CheckDisk(fileName);
|
|
486 |
if (r!=KErrNone && r!=KErrNotSupported)
|
|
487 |
{
|
|
488 |
aTest.Printf(_L("ERROR:: CheckDisk returned %d\n"),r);
|
|
489 |
aTest.Getch();
|
|
490 |
}
|
|
491 |
|
|
492 |
while(count--)
|
|
493 |
DeleteFileX(fileName,count,iFs,CurrentDrive(aTest),aTest);
|
|
494 |
|
|
495 |
r=iFs.CheckDisk(fileName);
|
|
496 |
if (r!=KErrNone && r!=KErrNotSupported)
|
|
497 |
{
|
|
498 |
aTest.Printf(_L("ERROR:: CheckDisk returned %d\n"),r);
|
|
499 |
aTest.Getch();
|
|
500 |
}
|
|
501 |
}
|
|
502 |
|
|
503 |
|
|
504 |
void TMultipleSessionTest::testSetVolume(RTest& aTest)
|
|
505 |
//
|
|
506 |
// Test setting the volume info.
|
|
507 |
//
|
|
508 |
{
|
|
509 |
|
|
510 |
aTest.Next(_L("Test setting the volume label"));
|
|
511 |
TInt r=iFs.SetSessionPath(iSessionPath);
|
|
512 |
aTest(r==KErrNone);
|
|
513 |
#if defined(_UNICODE)
|
|
514 |
aTest.Printf(_L("Unicode volume label set not implemented ****\n"));
|
|
515 |
return;
|
|
516 |
#else
|
|
517 |
TInt driveNum=CurrentDrive(aTest);
|
|
518 |
TVolumeInfo v;
|
|
519 |
r=iFs.Volume(v,driveNum);
|
|
520 |
aTest(r==KErrNone);
|
|
521 |
TFileName n=v.iName;
|
|
522 |
aTest.Printf(_L("VOL=\"%S\"\n"),&n);
|
|
523 |
|
|
524 |
aTest.Next(_L("Set volume label to nothing"));
|
|
525 |
r=iFs.SetVolumeLabel(_L(""),driveNum);
|
|
526 |
if (r==KErrGeneral)
|
|
527 |
return;
|
|
528 |
aTest(r==KErrNone);
|
|
529 |
r=iFs.Volume(v,driveNum);
|
|
530 |
aTest(r==KErrNone);
|
|
531 |
aTest(v.iName==_L(""));
|
|
532 |
aTest.Printf(_L("VOL=\"%S\"\n"),&v.iName);
|
|
533 |
|
|
534 |
aTest.Next(_L("Set volume label to ABCDEFGHIJK"));
|
|
535 |
r=iFs.SetVolumeLabel(_L("ABCDEFGHIJK"),driveNum);
|
|
536 |
aTest(r==KErrNone);
|
|
537 |
r=iFs.Volume(v,driveNum);
|
|
538 |
aTest(r==KErrNone);
|
|
539 |
aTest(v.iName==_L("ABCDEFGHIJK"));
|
|
540 |
aTest.Printf(_L("VOL=\"%S\"\n"),&v.iName);
|
|
541 |
|
|
542 |
aTest.Next(_L("Set volume label back to nothing"));
|
|
543 |
r=iFs.SetVolumeLabel(_L(""),driveNum);
|
|
544 |
aTest(r==KErrNone);
|
|
545 |
r=iFs.Volume(v,driveNum);
|
|
546 |
aTest(r==KErrNone);
|
|
547 |
aTest(v.iName==_L(""));
|
|
548 |
aTest.Printf(_L("VOL=\"%S\"\n"),&v.iName);
|
|
549 |
|
|
550 |
aTest.Next(_L("Set volume label to original"));
|
|
551 |
r=iFs.SetVolumeLabel(n,driveNum);
|
|
552 |
aTest(r==KErrNone);
|
|
553 |
r=iFs.Volume(v,driveNum);
|
|
554 |
aTest(r==KErrNone);
|
|
555 |
aTest(v.iName==n);
|
|
556 |
aTest.Printf(_L("VOL=\"%S\"\n"),&v.iName);
|
|
557 |
|
|
558 |
#endif
|
|
559 |
}
|
|
560 |
|
|
561 |
|
|
562 |
LOCAL_C void printDriveAtt(TInt aDrive,TUint anAtt,RTest& aTest)
|
|
563 |
//
|
|
564 |
// Print a drive attribute.
|
|
565 |
//
|
|
566 |
{
|
|
567 |
|
|
568 |
aTest.Printf(_L("%c: "),aDrive+'A');
|
|
569 |
if (anAtt&KDriveAttRemote)
|
|
570 |
aTest.Printf(_L("REMOTE "));
|
|
571 |
else if (anAtt&KDriveAttLocal)
|
|
572 |
aTest.Printf(_L("LOCAL "));
|
|
573 |
if (anAtt&KDriveAttRom)
|
|
574 |
aTest.Printf(_L("ROM "));
|
|
575 |
if (anAtt&KDriveAttRedirected)
|
|
576 |
aTest.Printf(_L("REDIRECTED "));
|
|
577 |
if (anAtt&KDriveAttSubsted)
|
|
578 |
aTest.Printf(_L("SUBST "));
|
|
579 |
if (anAtt&KDriveAttInternal)
|
|
580 |
aTest.Printf(_L("INTERNAL "));
|
|
581 |
if (anAtt&KDriveAttRemovable)
|
|
582 |
aTest.Printf(_L("REMOVABLE "));
|
|
583 |
aTest.Printf(_L("\n"));
|
|
584 |
}
|
|
585 |
|
|
586 |
LOCAL_C void printDriveInfo(TInt aDrive,TDriveInfo& anInfo,RTest& aTest)
|
|
587 |
//
|
|
588 |
// Print a drive info.
|
|
589 |
//
|
|
590 |
{
|
|
591 |
|
|
592 |
printDriveAtt(aDrive,anInfo.iDriveAtt,aTest);
|
|
593 |
aTest.Printf(_L(" MEDIA-ATT="));
|
|
594 |
if (anInfo.iMediaAtt==0)
|
|
595 |
aTest.Printf(_L("<none>"));
|
|
596 |
if (anInfo.iMediaAtt&KMediaAttVariableSize)
|
|
597 |
aTest.Printf(_L("VariableSize "));
|
|
598 |
if (anInfo.iMediaAtt&KMediaAttDualDensity)
|
|
599 |
aTest.Printf(_L("DualDensity "));
|
|
600 |
if (anInfo.iMediaAtt&KMediaAttFormattable)
|
|
601 |
aTest.Printf(_L("Formattable "));
|
|
602 |
if (anInfo.iMediaAtt&KMediaAttWriteProtected)
|
|
603 |
aTest.Printf(_L("WProtected "));
|
|
604 |
aTest.Printf(_L("\n BATTERY="));
|
|
605 |
switch(anInfo.iBattery)
|
|
606 |
{
|
|
607 |
case EBatNotSupported: aTest.Printf(_L("Not supported\n")); break;
|
|
608 |
case EBatGood: aTest.Printf(_L("Good\n")); break;
|
|
609 |
case EBatLow: aTest.Printf(_L("Low\n")); break;
|
|
610 |
default:
|
|
611 |
aTest.Printf(_L("Unknown value\n"));
|
|
612 |
}
|
|
613 |
aTest.Printf(_L(" MEDIA="));
|
|
614 |
switch(anInfo.iType)
|
|
615 |
{
|
|
616 |
case EMediaNotPresent: aTest.Printf(_L("Not present\n")); break;
|
|
617 |
case EMediaUnknown: aTest.Printf(_L("Unknown\n")); break;
|
|
618 |
case EMediaFloppy: aTest.Printf(_L("Floppy\n")); break;
|
|
619 |
case EMediaHardDisk: aTest.Printf(_L("Hard disk\n")); break;
|
|
620 |
case EMediaCdRom: aTest.Printf(_L("CD Rom\n")); break;
|
|
621 |
case EMediaRam: aTest.Printf(_L("Ram\n")); break;
|
|
622 |
case EMediaFlash: aTest.Printf(_L("Flash\n")); break;
|
|
623 |
case EMediaRom: aTest.Printf(_L("Rom\n")); break;
|
|
624 |
case EMediaRemote: aTest.Printf(_L("Remote\n")); break;
|
|
625 |
default:
|
|
626 |
aTest.Printf(_L("Unknown value\n"));
|
|
627 |
}
|
|
628 |
}
|
|
629 |
|
|
630 |
LOCAL_C void DriveInformation(TInt aDrive,TDriveInfo& anInfo,RTest& aTest)
|
|
631 |
//
|
|
632 |
// Test the drive info is reasonable
|
|
633 |
//
|
|
634 |
{
|
|
635 |
|
|
636 |
aTest(anInfo.iBattery==EBatLow || anInfo.iBattery==EBatGood || anInfo.iBattery==EBatNotSupported);
|
|
637 |
|
|
638 |
if (aDrive==EDriveZ)
|
|
639 |
{
|
|
640 |
if (anInfo.iType==EMediaNotPresent)
|
|
641 |
return;
|
|
642 |
|
|
643 |
aTest(anInfo.iMediaAtt==KMediaAttWriteProtected);
|
|
644 |
aTest(anInfo.iDriveAtt==(KDriveAttRom|KDriveAttInternal));
|
|
645 |
aTest(anInfo.iType==EMediaRom);
|
|
646 |
}
|
|
647 |
|
|
648 |
else if (aDrive==EDriveC || aDrive==EDriveY)
|
|
649 |
{
|
|
650 |
if (anInfo.iType==EMediaNotPresent)
|
|
651 |
return;
|
|
652 |
|
|
653 |
aTest(anInfo.iDriveAtt==(KDriveAttLocal|KDriveAttInternal));
|
|
654 |
aTest(anInfo.iType==EMediaHardDisk);
|
|
655 |
aTest(anInfo.iMediaAtt==(KMediaAttVariableSize|KMediaAttFormattable));
|
|
656 |
}
|
|
657 |
else if (aDrive==EDriveD || aDrive==EDriveX)
|
|
658 |
{
|
|
659 |
if (anInfo.iType==EMediaNotPresent)
|
|
660 |
return;
|
|
661 |
|
|
662 |
aTest(anInfo.iDriveAtt==(KDriveAttLocal|KDriveAttRemovable));
|
|
663 |
aTest(anInfo.iType==EMediaHardDisk);
|
|
664 |
aTest(anInfo.iMediaAtt==KMediaAttFormattable);
|
|
665 |
}
|
|
666 |
}
|
|
667 |
|
|
668 |
|
|
669 |
|
|
670 |
GLDEF_C void ReportCheckDiskFailure(TInt aRet,RTest& aTest)
|
|
671 |
//
|
|
672 |
// Report the failure of checkdisk
|
|
673 |
//
|
|
674 |
{
|
|
675 |
|
|
676 |
aTest.Printf(_L("CHECKDISK FAILED: "));
|
|
677 |
switch(aRet)
|
|
678 |
{
|
|
679 |
case 1: aTest.Printf(_L("File cluster chain contains a bad value (<2 or >maxCluster)\n")); break;
|
|
680 |
case 2: aTest.Printf(_L("Two files are linked to the same cluster\n")); break;
|
|
681 |
case 3: aTest.Printf(_L("Unallocated cluster contains a value != 0\n")); break;
|
|
682 |
case 4: aTest.Printf(_L("Size of file != number of clusters in chain\n")); break;
|
|
683 |
default: aTest.Printf(_L("Undefined Error value %d\n"),aRet);
|
|
684 |
}
|
|
685 |
aTest.Printf(_L("Press any key to continue\n"));
|
|
686 |
aTest.Getch();
|
|
687 |
}
|
|
688 |
|
|
689 |
|
|
690 |
|
|
691 |
TInt TMultipleSessionTest::CurrentDrive(RTest& aTest)
|
|
692 |
//
|
|
693 |
// Return the current drive number
|
|
694 |
//
|
|
695 |
{
|
|
696 |
TInt r=iFs.SetSessionPath(iSessionPath);
|
|
697 |
aTest(r==KErrNone);
|
|
698 |
TInt driveNum;
|
|
699 |
r=iFs.CharToDrive(iSessionPath[0],driveNum);
|
|
700 |
aTest(r==KErrNone);
|
|
701 |
return(driveNum);
|
|
702 |
}
|
|
703 |
|
|
704 |
|
|
705 |
|
|
706 |
|