|
1 // Copyright (c) 2004-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 "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 // Note : Testing for file uri component extraction for external media drive will be done only |
|
15 // if an external media drive does exist |
|
16 // |
|
17 // |
|
18 |
|
19 #include "CFileUriTest.h" |
|
20 |
|
21 #include <e32base.h> |
|
22 #include <escapeutils.h> |
|
23 #include "FileUriTestCommon.h" |
|
24 |
|
25 //File URI Constents |
|
26 _LIT8(KFileUriScheme8, "file"); |
|
27 _LIT16(KFileUriScheme16, "file"); |
|
28 |
|
29 // |
|
30 // |
|
31 // File Uri Tests |
|
32 // |
|
33 // |
|
34 |
|
35 CFileUriTest* CFileUriTest::NewLC(CIpuTestHarness* aTestHarness) |
|
36 { |
|
37 CFileUriTest* self = new (ELeave) CFileUriTest(aTestHarness); |
|
38 CleanupStack::PushL(self); |
|
39 self->ConstructL(); |
|
40 return self; |
|
41 } |
|
42 |
|
43 CFileUriTest* CFileUriTest::NewL(CIpuTestHarness* aTestHarness) |
|
44 { |
|
45 CFileUriTest* self = CFileUriTest::NewLC(aTestHarness); |
|
46 CleanupStack::Pop(self); |
|
47 return self; |
|
48 } |
|
49 |
|
50 CFileUriTest::CFileUriTest(CIpuTestHarness* aTestHarness) |
|
51 : iTestHarness(aTestHarness) |
|
52 { |
|
53 } |
|
54 |
|
55 void CFileUriTest::ConstructL() |
|
56 { |
|
57 } |
|
58 |
|
59 CFileUriTest::~CFileUriTest() |
|
60 { |
|
61 } |
|
62 |
|
63 void CFileUriTest::DoTestsL() |
|
64 { |
|
65 TBuf<3> drive(_L("$:\\")); |
|
66 //File URI Creation Test - for public files on fixed and removable media |
|
67 //---------------------------------------------------------------------------------- |
|
68 _LIT(KFullFileName, "c:\\public\\bar\\foo\\some\\randomness.txt"); |
|
69 |
|
70 //Testing 8-bit & 16-bit File URI creation for public file on a fixed drive |
|
71 _LIT(KExpectedUri, "file://c/public/bar/foo/some/randomness.txt"); |
|
72 TestFileUriCreationL(KFullFileName, KExpectedUri, 0); |
|
73 |
|
74 _LIT(KFullFileName2, "c:\\dummy\\file.txt"); |
|
75 _LIT(KExpectedUri3, "file://c/dummy/file.txt"); |
|
76 TestFileUriCreationL(KFullFileName2, KExpectedUri3, 0); |
|
77 |
|
78 _LIT(KFullFileName1, "c:\\randomness.txt"); |
|
79 |
|
80 //Testing 8-bit & 16-bit File URI creation for public file on a fixed drive |
|
81 _LIT(KExpectedUri2, "file://c/randomness.txt"); |
|
82 TestFileUriCreationL(KFullFileName1, KExpectedUri2, 0); |
|
83 |
|
84 //Testing 8-bit & 16-bit File URI creation for public file on a removable media drive |
|
85 _LIT(KExpectedUri1, "file://ext-media/public/bar/foo/some/randomness.txt"); |
|
86 TestFileUriCreationL(KFullFileName, KExpectedUri1, EExtMedia); |
|
87 |
|
88 _LIT(KExtMediaFullFileName, "X:\\mydir\\myfile.ext"); |
|
89 _LIT(KExtMediaExpectedUri1, "file://ext-media/mydir/myfile.ext"); |
|
90 TestFileUriCreationL(KExtMediaFullFileName, KExtMediaExpectedUri1, EExtMedia); |
|
91 //---------------------------------------------------------------------------------- |
|
92 |
|
93 //File URI component extraction Test - Schema, Path and Filename - |
|
94 // - for public files on fixed and removable media |
|
95 //---------------------------------------------------------------------------------- |
|
96 _LIT(KFileName, "c:\\public\\bar\\foo\\some\\randomness.txt"); |
|
97 |
|
98 //Testing 8-bit & 16-bit File URI creation for public file on a fixed drive |
|
99 _LIT(KExpectedPath, "/c/public/bar/foo/some/randomness.txt"); |
|
100 TestFileUriComponentExtractionL(KFileName, KExpectedPath, KFileName, drive, 0); |
|
101 |
|
102 //Testing 8-bit & 16-bit File URI creation for public file on a fixed drive |
|
103 _LIT(KFileName1, "c:\\system\\·····.ini"); |
|
104 _LIT(KExpectedPath1, "/c/system/·····.ini"); |
|
105 TestFileUriComponentExtractionL(KFileName1, KExpectedPath1, KFileName1, drive, 0); |
|
106 |
|
107 //Creating files on removable media drive (X:) |
|
108 // Need to change the removable Drive letter if X doesn't exist or its not removable media drive |
|
109 RFs fs; |
|
110 User::LeaveIfError(fs.Connect()); |
|
111 CleanupClosePushL(fs); |
|
112 TDriveInfo driveInfo; |
|
113 TInt err = KErrNotFound; |
|
114 TInt driveNum = EDriveA; |
|
115 |
|
116 //Checking for extenal media drive does exist |
|
117 for (; driveNum <= EDriveZ && err!=KErrNone; driveNum++) |
|
118 { |
|
119 if (fs.Drive(driveInfo, driveNum ) == KErrNone |
|
120 && (driveInfo.iDriveAtt & KDriveAttRemovable)) |
|
121 { |
|
122 drive[0]= TInt16('A' + driveNum); |
|
123 err = KErrNone; |
|
124 } |
|
125 } |
|
126 |
|
127 // Test only if external media drive exist |
|
128 if (err == KErrNone) |
|
129 { |
|
130 driveNum--; |
|
131 |
|
132 User::LeaveIfError(fs.SetSessionPath(drive)); |
|
133 TInt ret = fs.MkDir(_L("\\mydir\\")); |
|
134 if (ret == KErrNone || ret == KErrAlreadyExists) |
|
135 { |
|
136 RFile file; |
|
137 ret = file.Create(fs,_L("\\mydir\\myfile.ext"),EFileWrite|EFileShareAny); |
|
138 file.Close(); |
|
139 if (ret == KErrNone || ret == KErrAlreadyExists) |
|
140 { |
|
141 //Testing 8-bit & 16-bit File URI creation for public file on a removable media drive |
|
142 _LIT(KExpectedExtMediaPath1, "/ext-media/mydir/myfile.ext"); |
|
143 TFileName extMediaFileName(KExtMediaFullFileName); |
|
144 extMediaFileName[0] = drive[0]; |
|
145 TestFileUriComponentExtractionL(extMediaFileName, KExpectedExtMediaPath1, extMediaFileName, drive, EExtMedia); |
|
146 CFileMan* fm = CFileMan::NewL(fs); |
|
147 ret = fm->RmDir(_L("\\mydir\\")); |
|
148 delete fm; |
|
149 } |
|
150 } |
|
151 } |
|
152 |
|
153 CleanupStack::PopAndDestroy(&fs); |
|
154 //---------------------------------------------------------------------------------- |
|
155 |
|
156 //File URI component extraction, obj created using CUri::NewLC Test |
|
157 // - Schema, Path and Filename |
|
158 //---------------------------------------------------------------------------------- |
|
159 |
|
160 TestFileUriCreationWithOldAPIAndComponentExtractionL(KFileName, KExpectedPath, KFileName ); |
|
161 |
|
162 //---------------------------------------------------------------------------------- |
|
163 |
|
164 // resolve %-codes |
|
165 TestFileUriNameExtractionL(_L("file://c/dir/test/file%20name.html"), _L("file name.html"), _L("\\dir\\test\\file name.html") ); |
|
166 // params in path |
|
167 TestFileUriNameExtractionL(_L("http://www.text.org/cgi-bin/apps/index.html;one;two;three"), _L("index.html"), _L("\\cgi-bin\\apps\\index.html") ); |
|
168 |
|
169 // resolve %-codes |
|
170 TestFileUriNameExtractionL(_L8("file://c/dir/test/file%20name.html"), _L("file name.html"), _L("\\dir\\test\\file name.html") ); |
|
171 |
|
172 // params in path |
|
173 TestFileUriNameExtractionL(_L8("http://www.text.org/cgi-bin/apps/index.html;one;two;three"), _L("index.html"), _L("\\cgi-bin\\apps\\index.html") ); |
|
174 |
|
175 //---------------------------------------------------------------------------------- |
|
176 |
|
177 |
|
178 |
|
179 //File URI Creation Test - for private files on fixed and removable media |
|
180 //---------------------------------------------------------------------------------- |
|
181 |
|
182 //Testing 8-bit & 16-bit File URI creation for private file on a fixed drive |
|
183 _LIT(KExpectedprivateUri, "file://private/Z/bar/foo/some/randomness.txt"); |
|
184 |
|
185 _LIT(KRelativeFileName, "c:\\bar\\foo\\some\\randomness.txt"); |
|
186 TestPrivateFileUriCreationL(KRelativeFileName, EDriveZ, KExpectedprivateUri, 0); |
|
187 |
|
188 _LIT(KRelativeFileName1, "\\bar\\foo\\some\\randomness.txt"); |
|
189 TestPrivateFileUriCreationL(KRelativeFileName1, EDriveZ, KExpectedprivateUri, 0); |
|
190 |
|
191 _LIT(KRelativeFileName2, "bar\\foo\\some\\randomness.txt"); |
|
192 TestPrivateFileUriCreationL(KRelativeFileName2, EDriveZ, KExpectedprivateUri, 0); |
|
193 |
|
194 //Testing 8-bit & 16-bit File URI creation for private file on a removable media drive |
|
195 _LIT(KExtMediaRelativeFileName, "\\mydir\\myfile.ext"); |
|
196 _LIT(KExpectedPrivateExtMediaUri, "file://private/ext-media/mydir/myfile.ext"); |
|
197 TestPrivateFileUriCreationL(KExtMediaRelativeFileName, EDriveZ, KExpectedPrivateExtMediaUri, EExtMedia); |
|
198 //---------------------------------------------------------------------------------- |
|
199 |
|
200 //File URI component extraction Test - Schema, Path and Filename - |
|
201 // - for private files on fixed and removable media |
|
202 //---------------------------------------------------------------------------------- |
|
203 |
|
204 //Retrieveing application private path |
|
205 |
|
206 User::LeaveIfError(fs.Connect()); |
|
207 CleanupClosePushL(fs); |
|
208 TPath applPrivatePath; |
|
209 User::LeaveIfError(fs.PrivatePath(applPrivatePath)); |
|
210 CleanupStack::PopAndDestroy(&fs); |
|
211 |
|
212 //Testing 8-bit & 16-bit File URI creation for private file on a fixed drive |
|
213 _LIT(KExpectedPrivateFilePath, "/private/Z/bar/foo/some/randomness.txt"); |
|
214 _LIT(KExpectedPrivateFileName, "bar\\foo\\some\\randomness.txt"); |
|
215 TFileName expectedPrivateFileName(_L("Z:")); |
|
216 expectedPrivateFileName.Append(applPrivatePath); |
|
217 expectedPrivateFileName.Append(KExpectedPrivateFileName); |
|
218 |
|
219 TestPrivateFileUriComponentExtractionL(KRelativeFileName1, EDriveZ, KExpectedPrivateFilePath, expectedPrivateFileName, 0); |
|
220 |
|
221 //Testing 8-bit & 16-bit File URI creation for private file on a removable media drive |
|
222 _LIT(KExpectedPrivateExtMediaFilePath, "/private/ext-media/mydir/myfile.ext"); |
|
223 expectedPrivateFileName[0] = drive[0]; |
|
224 |
|
225 //Since we can't create folder "private" on removable media drive for testing purpose, the file extraction testing is not possible. |
|
226 // So need to pass KNullDesC to avoid file extraction |
|
227 TestPrivateFileUriComponentExtractionL(KExtMediaRelativeFileName, EDriveZ, KExpectedPrivateExtMediaFilePath, KNullDesC, EExtMedia); |
|
228 //---------------------------------------------------------------------------------- |
|
229 } |
|
230 |
|
231 void CFileUriTest::TestFileUriCreationL(const TDesC16& aFullFileName, const TDesC16& aExpectedUri, TUint aFlags) const |
|
232 { |
|
233 //Testing 8-bit File URI creation for public file on a fixed drive |
|
234 iTestHarness->StartTestL(_L("Test CUri - Public File URI creation (8bit)")); |
|
235 iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tExpected URI:%S"), &aFullFileName, aFlags, &aExpectedUri); |
|
236 TInt error = KErrNone; |
|
237 CUri8* uri8 = CUri8::CreateFileUriL(aFullFileName,aFlags); |
|
238 CleanupStack::PushL(uri8); |
|
239 HBufC8* expectedUri8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aExpectedUri); |
|
240 CleanupStack::PushL(expectedUri8); |
|
241 error = DoFileUriExtraction<CUri8>(*uri8, *expectedUri8); |
|
242 CleanupStack::PopAndDestroy(expectedUri8); |
|
243 CleanupStack::PopAndDestroy(uri8); |
|
244 iTestHarness->EndTest(error); |
|
245 |
|
246 //Testing 16-bit File URI creation for public file on a fixed drive |
|
247 error = KErrNone; |
|
248 iTestHarness->StartTestL(_L("Test CUri - File URI creation (16bit)")); |
|
249 iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileType:%D; \n\t\tExpected URI:%S"), &aFullFileName, aFlags, &aExpectedUri); |
|
250 CUri16* uri16 = CUri16::CreateFileUriL(aFullFileName,aFlags); |
|
251 CleanupStack::PushL(uri16); |
|
252 error = DoFileUriExtraction<CUri16>(*uri16, aExpectedUri); |
|
253 CleanupStack::PopAndDestroy(uri16); |
|
254 iTestHarness->EndTest(error); |
|
255 } |
|
256 |
|
257 void CFileUriTest::TestPrivateFileUriCreationL(const TDesC16& aRelativeFileName, const TDriveNumber aDrive, const TDesC16& aExpectedUri, TUint aFlags) const |
|
258 { |
|
259 //Testing 8-bit File URI creation for public file on a fixed drive |
|
260 iTestHarness->StartTestL(_L("Test CUri - Private File URI creation (8bit)")); |
|
261 iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tDrive:%c; \n\t\tExpectedURI:%S"), &aRelativeFileName, aFlags, ('A' + aDrive), &aExpectedUri); |
|
262 TInt error = KErrNone; |
|
263 CUri8* uri8 = CUri8::CreatePrivateFileUriL(aRelativeFileName,aDrive,aFlags); |
|
264 CleanupStack::PushL(uri8); |
|
265 HBufC8* expectedUri8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aExpectedUri); |
|
266 error = DoFileUriExtraction<CUri8>(*uri8, *expectedUri8); |
|
267 delete expectedUri8; |
|
268 CleanupStack::PopAndDestroy(uri8); |
|
269 iTestHarness->EndTest(error); |
|
270 |
|
271 //Testing 16-bit File URI creation for public file on a fixed drive |
|
272 error = KErrNone; |
|
273 iTestHarness->StartTestL(_L("Test CUri - Private File URI creation (16bit)")); |
|
274 iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tDrive:%c; \n\t\tExpectedURI:%S"), &aRelativeFileName, aFlags, ('A' + aDrive), &aExpectedUri); |
|
275 CUri16* uri16 = CUri16::CreatePrivateFileUriL(aRelativeFileName,aDrive,aFlags); |
|
276 CleanupStack::PushL(uri16); |
|
277 error = DoFileUriExtraction<CUri16>(*uri16, aExpectedUri); |
|
278 CleanupStack::PopAndDestroy(uri16); |
|
279 iTestHarness->EndTest(error); |
|
280 } |
|
281 |
|
282 void CFileUriTest::TestFileUriComponentExtractionL(const TDesC16& aFileName, const TDesC16& aPath, const TDesC16& aExpectedFileName, const TDesC16& aExpectedDrive, TUint aFlags) const |
|
283 { |
|
284 iTestHarness->StartTestL(_L("Test File Uri Component Extraction (8-bit)")); |
|
285 iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tPath:%S"), &aFileName,aFlags, &aPath); |
|
286 HBufC8* fileUriScheme8 = HBufC8::NewLC(4); |
|
287 fileUriScheme8->Des().Copy(KFileUriScheme8); |
|
288 |
|
289 HBufC* fileUriScheme16 = HBufC::NewLC(4); |
|
290 fileUriScheme16->Des().Copy(KFileUriScheme16); |
|
291 |
|
292 RFs fs; |
|
293 User::LeaveIfError(fs.Connect()); |
|
294 CleanupClosePushL(fs); |
|
295 CFileMan *fm = CFileMan::NewL(fs); |
|
296 CleanupStack::PushL(fm); |
|
297 |
|
298 TInt len = aFileName.Length(); |
|
299 TInt ret = 0; |
|
300 |
|
301 //Testing 8-bit File URI componet extraction for public file on a fixed drive |
|
302 TInt error = KErrNone; |
|
303 |
|
304 CUri8* uri8 = CUri8::CreateFileUriL(aFileName,aFlags); |
|
305 CleanupStack::PushL(uri8); |
|
306 |
|
307 HBufC8* path8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aPath); |
|
308 CleanupStack::PushL(path8); |
|
309 |
|
310 HBufC8* escapedUriPath8 = EscapeUtils::EscapeEncodeL(*path8, EscapeUtils::EEscapeNormal); |
|
311 CleanupStack::PushL(escapedUriPath8); |
|
312 |
|
313 error = DoFileUriComponentExtraction<TUriParser8, CUri8>(*uri8, *fileUriScheme8, *escapedUriPath8, aExpectedFileName); |
|
314 |
|
315 iTestHarness->EndTest(error); |
|
316 |
|
317 //-ve testing : After renaming file it should return error |
|
318 if (aFlags == EExtMedia && error == KErrNone) |
|
319 { |
|
320 iTestHarness->StartTestL(_L("EXT-MEDIA::Test File Uri Component Extraction(8-bit)")); |
|
321 iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tPath:%S; \n\t\tExpectedDrive:%S"), &aFileName,aFlags, &aPath, &aExpectedDrive); |
|
322 |
|
323 error = KErrNotFound; |
|
324 User::LeaveIfError(fs.SetSessionPath(aExpectedDrive)); |
|
325 ret = fm->Rename(aFileName,(aFileName.Left(len-4))); |
|
326 |
|
327 if (ret == KErrNone || ret == KErrAlreadyExists) |
|
328 { |
|
329 TRAP(error, (DoFileUriComponentExtraction<TUriParser8, CUri8>(*uri8, *fileUriScheme8, *path8, aExpectedFileName))); |
|
330 error = ((error != KErrNone) ? 0 : -1); |
|
331 ret = fm->Rename(aFileName.Left(aFileName.Length()-4),aFileName,CFileMan::EOverWrite); |
|
332 } |
|
333 |
|
334 iTestHarness->EndTest(error); |
|
335 } |
|
336 |
|
337 //Testing 16-bit File URI componet extraction for public file on a removable media drive |
|
338 iTestHarness->StartTestL(_L("Test File Uri Component Extraction (16-bit)")); |
|
339 iTestHarness->LogIt(_L("FileName: \n\t\t%S; \n\t\tFileStorageType:%D; \n\t\tPath:%S"), &aFileName, aFlags, &aPath); |
|
340 |
|
341 CUri16* uri16 = CUri16::CreateFileUriL(aFileName,aFlags); |
|
342 CleanupStack::PushL(uri16); |
|
343 |
|
344 HBufC* escapedUriPath = HBufC::NewLC(escapedUriPath8->Length()); |
|
345 escapedUriPath->Des().Copy(*escapedUriPath8); |
|
346 |
|
347 error = DoFileUriComponentExtraction<TUriParser16, CUri16, TDesC16>(*uri16, *fileUriScheme16, *escapedUriPath, aExpectedFileName); |
|
348 |
|
349 iTestHarness->EndTest(error); |
|
350 |
|
351 //-ve testing : After renaming file it should return error |
|
352 if (aFlags == EExtMedia && error == KErrNone) |
|
353 { |
|
354 iTestHarness->StartTestL(_L(" EXT-MEDIA::Test File Uri Component Extraction(16-bit)")); |
|
355 iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:%D; \n\t\tPath:%S; \n\t\tExpectedDrive:%S"), &aFileName,aFlags, &aPath, &aExpectedDrive); |
|
356 |
|
357 error = KErrNotFound; |
|
358 User::LeaveIfError(fs.SetSessionPath(aExpectedDrive)); |
|
359 ret = fm->Rename(aFileName,(aFileName.Left(len-4))); |
|
360 |
|
361 if (ret == KErrNone || ret == KErrAlreadyExists) |
|
362 { |
|
363 TRAP(error, (DoFileUriComponentExtraction<TUriParser16, CUri16, TDesC16>(*uri16, *fileUriScheme16, aPath, aExpectedFileName))); |
|
364 error = ((error != KErrNone) ? 0 : -1); |
|
365 ret = fm->Rename(aFileName.Left(aFileName.Length()-4),aFileName,CFileMan::EOverWrite); |
|
366 } |
|
367 |
|
368 iTestHarness->EndTest(error); |
|
369 } |
|
370 |
|
371 CleanupStack::PopAndDestroy(escapedUriPath); |
|
372 CleanupStack::PopAndDestroy(uri16); |
|
373 CleanupStack::PopAndDestroy(escapedUriPath8); |
|
374 CleanupStack::PopAndDestroy(path8); |
|
375 CleanupStack::PopAndDestroy(uri8); |
|
376 CleanupStack::PopAndDestroy(4, fileUriScheme8); //fileUriScheme8, fileUriScheme16,fs,fm |
|
377 } |
|
378 |
|
379 void CFileUriTest::TestPrivateFileUriComponentExtractionL(const TDesC16& aFileName, const TDriveNumber aDrive, const TDesC16& aPath, const TDesC16& aExpectedFileName, TUint aFlags) const |
|
380 { |
|
381 iTestHarness->StartTestL(_L("Test Private File Uri Component Extraction (8-bit)")); |
|
382 iTestHarness->LogIt(_L("FileName: %S; \n\t\tDrive:%c, \n\t\tFileStorageType:%D; \n\t\tPath:%S"), &aFileName, ('A' + aDrive), aFlags, &aPath); |
|
383 TInt error = KErrNone; |
|
384 HBufC8* fileUriScheme8 = HBufC8::NewLC(4); |
|
385 TPtr8 fileUriScheme8Ptr = fileUriScheme8->Des(); |
|
386 fileUriScheme8Ptr.Copy(KFileUriScheme8); |
|
387 HBufC* fileUriScheme16 = HBufC::NewLC(4); |
|
388 TPtr16 fileUriScheme16Ptr = fileUriScheme16->Des(); |
|
389 fileUriScheme16Ptr.Copy(KFileUriScheme16); |
|
390 |
|
391 //Testing 8-bit File URI componet extraction for private file on a fixed drive |
|
392 CUri8* prv_uri8 = CUri8::CreatePrivateFileUriL(aFileName,aDrive,aFlags); |
|
393 CleanupStack::PushL(prv_uri8); |
|
394 HBufC8* path8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aPath); |
|
395 error = DoFileUriComponentExtraction<TUriParser8>(*prv_uri8, *fileUriScheme8, *path8, aExpectedFileName); |
|
396 delete path8; |
|
397 CleanupStack::PopAndDestroy(prv_uri8); |
|
398 iTestHarness->EndTest(error); |
|
399 |
|
400 //Testing 16-bit File URI componet extraction for private file on a removable media drive |
|
401 iTestHarness->StartTestL(_L("Test Private File Uri Component Extraction (16-bit)")); |
|
402 iTestHarness->LogIt(_L("FileName: %S; \n\t\tDrive:%c, \n\t\tFileStorageType:%D; \n\t\tPath:%S"), &aFileName, ('A' + aDrive), aFlags, &aPath); |
|
403 CUri16* prv_uri16 = CUri16::CreatePrivateFileUriL(aFileName,aDrive,aFlags); |
|
404 CleanupStack::PushL(prv_uri16); |
|
405 error = DoFileUriComponentExtraction<TUriParser16, CUri16, TDesC16>(*prv_uri16, *fileUriScheme16, aPath, aExpectedFileName); |
|
406 CleanupStack::PopAndDestroy(prv_uri16); |
|
407 iTestHarness->EndTest(error); |
|
408 |
|
409 CleanupStack::PopAndDestroy(2, fileUriScheme8); //fileUriScheme8, fileUriScheme16 |
|
410 } |
|
411 |
|
412 void CFileUriTest::TestFileUriCreationWithOldAPIAndComponentExtractionL(const TDesC16& aFileName, const TDesC16& aPath, const TDesC16& aExpectedFileName) const |
|
413 { |
|
414 //Testing File URI componet extraction created using CUri::NewLC() |
|
415 iTestHarness->StartTestL(_L("Test File Uri Component Extraction created using NewLC (8-bit)")); |
|
416 iTestHarness->LogIt(_L("FileName: %S; \n\t\tPath:%S"), &aFileName, &aPath); |
|
417 TInt error = KErrNone; |
|
418 HBufC8* fileUriScheme8 = HBufC8::NewLC(4); |
|
419 TPtr8 fileUriScheme8Ptr = fileUriScheme8->Des(); |
|
420 fileUriScheme8Ptr.Copy(KFileUriScheme8); |
|
421 HBufC* fileUriScheme16 = HBufC::NewLC(4); |
|
422 TPtr16 fileUriScheme16Ptr = fileUriScheme16->Des(); |
|
423 fileUriScheme16Ptr.Copy(KFileUriScheme16); |
|
424 |
|
425 _LIT8(KFileUri8, "file://%S"); |
|
426 HBufC8* path8 = EscapeUtils::ConvertFromUnicodeToUtf8L(aPath); |
|
427 CleanupStack::PushL(path8); |
|
428 HBufC8 *fileUri8 = HBufC8::NewLC((path8->Length()+10)); |
|
429 TPtr8 fileUri8Ptr = fileUri8->Des(); |
|
430 fileUri8Ptr.AppendFormat(KFileUri8,path8); |
|
431 TUriParser8 urip8; |
|
432 urip8.Parse(*fileUri8); |
|
433 CUri8* _uri8 = CUri8::NewLC(urip8); |
|
434 error = DoFileUriComponentExtraction<TUriParser8, CUri8, TDesC8>(*_uri8, *fileUriScheme8, *path8, aExpectedFileName); |
|
435 CleanupStack::PopAndDestroy(_uri8); |
|
436 iTestHarness->EndTest(error); |
|
437 |
|
438 iTestHarness->StartTestL(_L("Test File Uri Component Extraction created using NewLC (16-bit)")); |
|
439 iTestHarness->LogIt(_L("FileName: %S; \n\t\tFileStorageType:2; \n\t\tPath:%S"), &aFileName, &aPath); |
|
440 HBufC *fileUri16 = EscapeUtils::ConvertToUnicodeFromUtf8L(*fileUri8); |
|
441 CleanupStack::PushL(fileUri16); |
|
442 TUriParser16 urip16; |
|
443 urip16.Parse(*fileUri16); |
|
444 CUri16* _uri16 = CUri16::NewLC(urip16); |
|
445 error = DoFileUriComponentExtraction<TUriParser16, CUri16, TDesC16>(*_uri16, *fileUriScheme16, aPath, aExpectedFileName); |
|
446 CleanupStack::PopAndDestroy(_uri16); |
|
447 iTestHarness->EndTest(error); |
|
448 |
|
449 CleanupStack::PopAndDestroy(5, fileUriScheme8); //fileUriScheme8, fileUriScheme16, path8, fileUri8, fileUri16 |
|
450 } |
|
451 |
|
452 // |
|
453 // |
|
454 // Implementation of LOCAL functions |
|
455 // |
|
456 // |
|
457 template<class CUriType, class TDesCType> |
|
458 TInt DoFileUriExtraction(const CUriType& aUri, const TDesCType& aExpectedFileUri) |
|
459 { |
|
460 TInt error = 0; |
|
461 |
|
462 // Check file URI... |
|
463 error = aUri.Uri().UriDes().Compare(aExpectedFileUri); |
|
464 if( error != 0 ) |
|
465 { |
|
466 return error; |
|
467 } |
|
468 return KErrNone; |
|
469 } |
|
470 |
|
471 template<class TUriParserType, class CUriType, class TDesCType, class TDesCType16> |
|
472 TInt DoFileUriComponentExtraction(const CUriType& aUri, const TDesCType& aScheme, const TDesCType& aPath, const TDesCType16& aExpectedFileName) |
|
473 { |
|
474 TUriParserType uriParser; |
|
475 TInt error = uriParser.Parse(aUri.Uri().UriDes()); |
|
476 // Is this a valid Uri? |
|
477 if( error == KUriUtilsErrInvalidUri ) |
|
478 { |
|
479 return error; |
|
480 } |
|
481 |
|
482 // Check scheme... |
|
483 if( (error = TestComponent(uriParser, aScheme, EUriScheme)) != 0 ) |
|
484 { |
|
485 return error; |
|
486 } |
|
487 |
|
488 // Check path... |
|
489 if( (error = TestComponent(uriParser, aPath, EUriPath)) != 0) |
|
490 { |
|
491 return error; |
|
492 } |
|
493 |
|
494 if (aExpectedFileName.Length() > 0) |
|
495 { |
|
496 HBufC* tmpFileName = uriParser.GetFileNameL(); |
|
497 error = tmpFileName->Compare(aExpectedFileName); |
|
498 delete tmpFileName; |
|
499 if (error != 0) |
|
500 { |
|
501 return error; |
|
502 } |
|
503 } |
|
504 |
|
505 return KErrNone; |
|
506 } |
|
507 |
|
508 template<class TParserType, class TDesCType, class TComponentType> |
|
509 TInt TestComponent(const TParserType& aParser, const TDesCType& aExpected, TComponentType aComponent) |
|
510 { |
|
511 return aParser.Extract(aComponent).Compare(aExpected); |
|
512 } |
|
513 |
|
514 |
|
515 void CFileUriTest::TestFileUriNameExtractionL(const TDesC& aUri, const TDesC& aFilename, const TDesC& aPath) |
|
516 { |
|
517 TUriParser uriParser; |
|
518 User::LeaveIfError(uriParser.Parse(aUri)); |
|
519 |
|
520 HBufC* name; |
|
521 TInt error = KErrNone; |
|
522 |
|
523 iTestHarness->StartTestL(_L("Test extract file name from URI (16 bit)")); |
|
524 iTestHarness->LogIt(_L("URI: %S; \n\t\tExpected name:%S"), &uriParser.UriDes(), &aFilename); |
|
525 |
|
526 name = uriParser.GetFileNameL(EUriFileNameTail); |
|
527 iTestHarness->LogIt(_L("Computed name:%S"), name); |
|
528 error = (aFilename.Compare(*name)==0) ? KErrNone : KErrBadName; |
|
529 delete name; |
|
530 |
|
531 iTestHarness->EndTest(error); |
|
532 |
|
533 iTestHarness->StartTestL(_L("Test extract file path from URI (16 bit)")); |
|
534 iTestHarness->LogIt(_L("URI: %S; \n\t\tExpected Path:%S"), &uriParser.UriDes(), &aPath); |
|
535 |
|
536 name = uriParser.GetFileNameL(EUriFileNamePath); |
|
537 iTestHarness->LogIt(_L("Computed Path:%S"), name); |
|
538 error = (aPath.Compare(*name)==0) ? KErrNone : KErrBadName; |
|
539 delete name; |
|
540 |
|
541 iTestHarness->EndTest(error); |
|
542 } |
|
543 |
|
544 void CFileUriTest::TestFileUriNameExtractionL(const TDesC8& aUri, const TDesC& aFilename, const TDesC& aPath) |
|
545 { |
|
546 TUriParser8 uriParser; |
|
547 User::LeaveIfError(uriParser.Parse(aUri)); |
|
548 |
|
549 HBufC* name; |
|
550 TInt error = KErrNone; |
|
551 |
|
552 TFileName uri; |
|
553 uri.Copy(uriParser.UriDes()); // safe for all valid URIs |
|
554 iTestHarness->StartTestL(_L("Test extract file name from URI (8 bit)")); |
|
555 iTestHarness->LogIt(_L("URI: %S; \n\t\tExpected name:%S"), &uri, &aFilename); |
|
556 |
|
557 name = uriParser.GetFileNameL(EUriFileNameTail); |
|
558 iTestHarness->LogIt(_L("Computed name:%S"), name); |
|
559 error = (aFilename.Compare(*name)==0) ? KErrNone : KErrBadName; |
|
560 delete name; |
|
561 |
|
562 iTestHarness->EndTest(error); |
|
563 |
|
564 iTestHarness->StartTestL(_L("Test extract file path from URI (8 bit)")); |
|
565 iTestHarness->LogIt(_L("URI: %S; \n\t\tExpected Path:%S"), &uri, &aPath); |
|
566 |
|
567 name = uriParser.GetFileNameL(EUriFileNamePath); |
|
568 iTestHarness->LogIt(_L("Computed Path:%S"), name); |
|
569 error = (aPath.Compare(*name)==0) ? KErrNone : KErrBadName; |
|
570 delete name; |
|
571 |
|
572 iTestHarness->EndTest(error); |
|
573 } |
|
574 |