|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: ExifLibTest |
|
15 * |
|
16 */ |
|
17 #include "ExifLibTestInc.h" |
|
18 |
|
19 |
|
20 // Exif.Modify.001 |
|
21 // Instantiate an Exif modifier with valid Exif image |
|
22 // Modified Exif modifier instance in EModify mode is returned. |
|
23 void CExifModifyTest2::ExifModify001L() |
|
24 { |
|
25 CExifModify* modify = CExifModify::NewL(); |
|
26 if(!modify) |
|
27 User::Leave(KErrGeneral); |
|
28 delete modify; |
|
29 } |
|
30 |
|
31 // Exif.Modify.002 |
|
32 // Try to instantiate an Exif modifier with invalid/ corrupted Exif image |
|
33 // Leaves with proper error code. |
|
34 void CExifModifyTest2::ExifModify002L() |
|
35 { |
|
36 |
|
37 CExifModify* modify = CExifModify::NewL(); |
|
38 CleanupStack::PushL(modify); |
|
39 |
|
40 // Insert Tags |
|
41 HBufC8* buf = 0; |
|
42 TUint16 tmp1 = 0; |
|
43 TUint32 tmp3 = 0; |
|
44 TUint32 tmp4 = 0; |
|
45 TInt32 tmp5 = 0; |
|
46 TInt32 tmp6 = 0; |
|
47 |
|
48 buf = TUtils::CreateDummyBufL(10); |
|
49 CleanupStack::PushL(buf); |
|
50 modify->SetUserCommentL(buf->Des()); |
|
51 CleanupStack::PopAndDestroy(buf); |
|
52 buf = 0; |
|
53 |
|
54 buf = TUtils::CreateDummyBufL(4); |
|
55 CleanupStack::PushL(buf); |
|
56 modify->SetModelL(buf->Des()); |
|
57 CleanupStack::PopAndDestroy(buf); |
|
58 buf = 0; |
|
59 |
|
60 tmp1 = 0; |
|
61 modify->SetMeteringModeL(tmp1); |
|
62 |
|
63 tmp5 = 1; |
|
64 tmp6 = 1; |
|
65 modify->SetExposureBiasValueL(tmp5, tmp6); |
|
66 |
|
67 tmp5 = 0; |
|
68 tmp6 = 1; |
|
69 modify->SetShutterSpeedValueL(tmp5, tmp6); |
|
70 |
|
71 modify->SetBrightnessValueL(tmp5, tmp6); |
|
72 |
|
73 modify->SetCustomRenderedL(0); |
|
74 |
|
75 modify->SetGainControlL(0); |
|
76 |
|
77 buf = TUtils::CreateDummyBufL(19); |
|
78 CleanupStack::PushL(buf); |
|
79 buf->Des().Copy(_L("2004:01:19 11:00:00")); |
|
80 modify->SetDateTimeOriginalL(buf->Des()); |
|
81 modify->SetDateTimeDigitizedL(buf->Des()); |
|
82 CleanupStack::PopAndDestroy(buf); |
|
83 buf = 0; |
|
84 |
|
85 tmp5 = 1; |
|
86 tmp6 = 1; |
|
87 modify->SetApertureValueL(tmp5, tmp6); |
|
88 |
|
89 tmp3 = 72; |
|
90 tmp4 = 1; |
|
91 modify->SetXResolutionL(tmp3, tmp4); |
|
92 modify->SetYResolutionL(tmp3, tmp4); |
|
93 tmp1 = 2; |
|
94 modify->SetResolutionUnitL(tmp1); |
|
95 tmp1 = 1; |
|
96 modify->SetYCbCrPositioningL(tmp1); |
|
97 |
|
98 modify->SetComponentsConfigurationL(1, 2, 3, 0); |
|
99 tmp1 = 1; |
|
100 modify->SetColorSpaceL(tmp1); |
|
101 tmp3 = 1024; |
|
102 modify->SetPixelXDimensionL(tmp3); |
|
103 tmp3 = 768; |
|
104 modify->SetPixelYDimensionL(tmp3); |
|
105 |
|
106 |
|
107 buf = TUtils::CreateDummyBufL(5); |
|
108 CleanupStack::PushL(buf); |
|
109 modify->SetImageDescriptionL(buf->Des()); |
|
110 CleanupStack::PopAndDestroy(buf); |
|
111 buf = 0; |
|
112 |
|
113 |
|
114 buf = TUtils::CreateDummyBufL(768*2); |
|
115 CleanupStack::PushL(buf); |
|
116 modify->SetTransferFunctionL(buf->Des()); |
|
117 CleanupStack::PopAndDestroy(buf); |
|
118 buf = 0; |
|
119 |
|
120 modify->SetExposureModeL(0); |
|
121 modify->SetWhiteBalanceL(0); |
|
122 modify->SetSceneCaptureTypeL(0); |
|
123 modify->SetExposureProgramL(0); |
|
124 |
|
125 modify->SetLightSourceL(0); |
|
126 |
|
127 buf = TUtils::CreateDummyBufL(16); |
|
128 CleanupStack::PushL(buf); |
|
129 modify->SetMakerNoteL(buf->Des()); |
|
130 CleanupStack::PopAndDestroy(buf); |
|
131 buf = 0; |
|
132 |
|
133 TPtrC8 tmpDes; |
|
134 HBufC8* buffer = modify->WriteDataL( tmpDes ); |
|
135 if(!buffer) |
|
136 User::Leave(KErrGeneral); |
|
137 delete buffer; |
|
138 buffer = 0; |
|
139 |
|
140 HBufC8* exif = TUtils::ReadFileL(iFs, KInvalidJpeg1); |
|
141 CleanupStack::PushL(exif); |
|
142 TRAPD( error, buffer = modify->WriteDataL( exif->Des() ) ); |
|
143 if( (error!=KErrNotSupported) || buffer) |
|
144 { |
|
145 if ( buffer ) |
|
146 delete buffer; |
|
147 buffer = 0; |
|
148 if ( error ) |
|
149 { |
|
150 User::Leave( error ); |
|
151 } |
|
152 User::Leave(KErrGeneral); |
|
153 } |
|
154 CleanupStack::PopAndDestroy( exif ); |
|
155 |
|
156 CleanupStack::PopAndDestroy(modify); |
|
157 } |
|
158 |
|
159 // Exif.Modify.003 |
|
160 // Retrieve reader instance for the related Exif data. |
|
161 // Returns unmodifiable reader instance. |
|
162 void CExifModifyTest2::ExifModify003L() |
|
163 { |
|
164 CExifModify* modify = CExifModify::NewL(); |
|
165 CleanupStack::PushL(modify); |
|
166 |
|
167 const CExifRead* reader = modify->Reader(); |
|
168 if(!reader) |
|
169 User::Leave(KErrGeneral); |
|
170 |
|
171 CleanupStack::PopAndDestroy(modify); |
|
172 } |
|
173 |
|
174 // Exif.Modify.004 |
|
175 // Insert/ Update a valid tag into the specified IFD in Exif data. |
|
176 // The given tag instance is inserted or updated. |
|
177 void CExifModifyTest2::ExifModify004L() |
|
178 { |
|
179 // For each IFD. |
|
180 |
|
181 |
|
182 CExifModify* modify = CExifModify::NewL(); |
|
183 CleanupStack::PushL(modify); |
|
184 |
|
185 |
|
186 HBufC8* buf = TUtils::CreateDummyBufL(16); |
|
187 CleanupStack::PushL(buf); |
|
188 TExifTagInfo tag(KIdImageDescription, CExifTag::ETagAscii, 16); |
|
189 modify->SetTagL(EIfd0, tag, buf->Des()); |
|
190 CleanupStack::PopAndDestroy(buf); |
|
191 |
|
192 buf = TUtils::CreateDummyBufL(20); |
|
193 CleanupStack::PushL(buf); |
|
194 tag.iId = KIdUserComment; |
|
195 tag.iDataType = CExifTag::ETagUndefined; |
|
196 tag.iDataCount = 20; |
|
197 modify->SetTagL(EIfdExif, tag, buf->Des()); |
|
198 CleanupStack::PopAndDestroy(buf); |
|
199 |
|
200 buf = TUtils::CreateDummyBufL(2); |
|
201 CleanupStack::PushL(buf); |
|
202 *(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 0; |
|
203 tag.iId = KIdExposureProgram; |
|
204 tag.iDataType = CExifTag::ETagShort; |
|
205 tag.iDataCount = 1; |
|
206 modify->SetTagL(EIfdExif, tag, buf->Des()); |
|
207 CleanupStack::PopAndDestroy(buf); |
|
208 |
|
209 buf = TUtils::CreateDummyBufL(1); |
|
210 CleanupStack::PushL(buf); |
|
211 tag.iId = 3; |
|
212 tag.iDataType = CExifTag::ETagAscii; |
|
213 tag.iDataCount = 1; |
|
214 modify->SetTagL(EIfdGps, tag, buf->Des()); |
|
215 CleanupStack::PopAndDestroy(buf); |
|
216 |
|
217 buf = TUtils::CreateDummyBufL(3); |
|
218 CleanupStack::PushL(buf); |
|
219 tag.iId = 1; |
|
220 tag.iDataType = CExifTag::ETagAscii; |
|
221 tag.iDataCount = 3; |
|
222 modify->SetTagL(EIfdIntOp, tag, buf->Des()); |
|
223 CleanupStack::PopAndDestroy(buf); |
|
224 |
|
225 buf = TUtils::CreateDummyBufL(2); |
|
226 CleanupStack::PushL(buf); |
|
227 *(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 2; |
|
228 tag.iId = KIdResolutionUnit; |
|
229 tag.iDataType = CExifTag::ETagShort; |
|
230 tag.iDataCount = 1; |
|
231 modify->SetTagL(EIfd1, tag, buf->Des()); |
|
232 CleanupStack::PopAndDestroy(buf); |
|
233 |
|
234 CleanupStack::PopAndDestroy(modify); |
|
235 |
|
236 } |
|
237 |
|
238 // Exif.Modify.005 |
|
239 // Try to insert/ update a valid tag into the specified IFD in Exif data. |
|
240 // Leaves with proper error code. |
|
241 void CExifModifyTest2::ExifModify005L() |
|
242 { |
|
243 //* Tag is not allowed to be inserted into the specified IFD, |
|
244 |
|
245 |
|
246 CExifModify* modify = CExifModify::NewL(); |
|
247 CleanupStack::PushL(modify); |
|
248 |
|
249 |
|
250 HBufC8* buf = TUtils::CreateDummyBufL(16); |
|
251 CleanupStack::PushL(buf); |
|
252 TExifTagInfo tag(KIdImageDescription, CExifTag::ETagAscii, 16); |
|
253 TRAPD(error, modify->SetTagL(EIfdExif, tag, buf->Des())); |
|
254 if(error != KErrNotSupported) |
|
255 { |
|
256 if(error) |
|
257 User::Leave(error); |
|
258 User::Leave(KErrGeneral); |
|
259 } |
|
260 CleanupStack::PopAndDestroy(buf); |
|
261 |
|
262 buf = TUtils::CreateDummyBufL(20); |
|
263 CleanupStack::PushL(buf); |
|
264 tag.iId = KIdUserComment; |
|
265 tag.iDataType = CExifTag::ETagUndefined; |
|
266 tag.iDataCount = 20; |
|
267 TRAP(error, modify->SetTagL(EIfd1, tag, buf->Des())); |
|
268 if(error != KErrNotSupported) |
|
269 { |
|
270 if(error) |
|
271 User::Leave(error); |
|
272 User::Leave(KErrGeneral); |
|
273 } |
|
274 CleanupStack::PopAndDestroy(buf); |
|
275 |
|
276 buf = TUtils::CreateDummyBufL(2); |
|
277 CleanupStack::PushL(buf); |
|
278 *(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 0; |
|
279 tag.iId = KIdExposureProgram; |
|
280 tag.iDataType = CExifTag::ETagShort; |
|
281 tag.iDataCount = 1; |
|
282 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
283 if(error != KErrNotSupported) |
|
284 { |
|
285 if(error) |
|
286 User::Leave(error); |
|
287 User::Leave(KErrGeneral); |
|
288 } |
|
289 CleanupStack::PopAndDestroy(buf); |
|
290 |
|
291 buf = TUtils::CreateDummyBufL(2); |
|
292 CleanupStack::PushL(buf); |
|
293 tag.iId = 3; |
|
294 tag.iDataType = CExifTag::ETagAscii; |
|
295 tag.iDataCount = 2; |
|
296 TRAP(error, modify->SetTagL(EIfdIntOp, tag, buf->Des())); |
|
297 if(error != KErrNotSupported) |
|
298 { |
|
299 if(error) |
|
300 User::Leave(error); |
|
301 User::Leave(KErrGeneral); |
|
302 } |
|
303 |
|
304 CleanupStack::PopAndDestroy(buf); |
|
305 |
|
306 buf = TUtils::CreateDummyBufL(3); |
|
307 CleanupStack::PushL(buf); |
|
308 tag.iId = 1; |
|
309 tag.iDataType = CExifTag::ETagAscii; |
|
310 tag.iDataCount = 3; |
|
311 TRAP(error, modify->SetTagL(EIfdExif, tag, buf->Des())); |
|
312 if(error != KErrNotSupported) |
|
313 { |
|
314 if(error) |
|
315 User::Leave(error); |
|
316 User::Leave(KErrGeneral); |
|
317 } |
|
318 CleanupStack::PopAndDestroy(buf); |
|
319 |
|
320 buf = TUtils::CreateDummyBufL(2); |
|
321 CleanupStack::PushL(buf); |
|
322 *(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 2; |
|
323 tag.iId = KIdResolutionUnit; |
|
324 tag.iDataType = CExifTag::ETagShort; |
|
325 tag.iDataCount = 1; |
|
326 TRAP(error, modify->SetTagL(EIfdGps, tag, buf->Des())); |
|
327 if(error != KErrNotSupported) |
|
328 { |
|
329 if(error) |
|
330 User::Leave(error); |
|
331 User::Leave(KErrGeneral); |
|
332 } |
|
333 CleanupStack::PopAndDestroy(buf); |
|
334 |
|
335 //* The Exif data size exceeds 64K" |
|
336 buf = TUtils::CreateDummyBufL(65520); |
|
337 CleanupStack::PushL(buf); |
|
338 tag.iId = KIdImageDescription; |
|
339 tag.iDataType = CExifTag::ETagAscii; |
|
340 tag.iDataCount = 65520; |
|
341 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
342 if(error != KErrOverflow) |
|
343 { |
|
344 if(error) |
|
345 User::Leave(error); |
|
346 User::Leave(KErrGeneral); |
|
347 } |
|
348 CleanupStack::PopAndDestroy(buf); |
|
349 |
|
350 // Tag ID is invalid, |
|
351 buf = TUtils::CreateDummyBufL(19); |
|
352 CleanupStack::PushL(buf); |
|
353 tag.iId = 200; |
|
354 tag.iDataType = CExifTag::ETagAscii; |
|
355 tag.iDataCount = 19; |
|
356 TRAP(error, modify->SetTagL(EIfdGps, tag, buf->Des())); |
|
357 if(error != KErrNotSupported) |
|
358 { |
|
359 if(error) |
|
360 User::Leave(error); |
|
361 User::Leave(KErrGeneral); |
|
362 } |
|
363 CleanupStack::PopAndDestroy(buf); |
|
364 |
|
365 //Tag ID doesn't match with the data type, (Full validity) |
|
366 //* Not supported yet!!! |
|
367 buf = TUtils::CreateDummyBufL(19); |
|
368 CleanupStack::PushL(buf); |
|
369 tag.iId = KIdImageDescription; |
|
370 tag.iDataType = CExifTag::ETagByte; |
|
371 tag.iDataCount = 19; |
|
372 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
373 if(error != KErrNotSupported) |
|
374 { |
|
375 if(error) |
|
376 User::Leave(error); |
|
377 User::Leave(KErrGeneral); |
|
378 } |
|
379 CleanupStack::PopAndDestroy(buf); |
|
380 //*/ |
|
381 |
|
382 //Data count doesn't match with the given tag data size |
|
383 buf = TUtils::CreateDummyBufL(19); |
|
384 CleanupStack::PushL(buf); |
|
385 tag.iId = KIdImageDescription; |
|
386 tag.iDataType = CExifTag::ETagAscii; |
|
387 tag.iDataCount = 24; |
|
388 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
389 if(error != KErrArgument) |
|
390 { |
|
391 if(error) |
|
392 User::Leave(error); |
|
393 User::Leave(KErrGeneral); |
|
394 } |
|
395 CleanupStack::PopAndDestroy(buf); |
|
396 |
|
397 //Tag data value is not valid (Full validity) |
|
398 // !! DROPPED |
|
399 /* Not supported yet!!! |
|
400 buf = TUtils::CreateDummyBufL(2); |
|
401 CleanupStack::PushL(buf); |
|
402 tag.iId = KIdImageDescription; |
|
403 tag.iDataType = CExifTag::ETagShort; |
|
404 tag.iDataCount = 2; |
|
405 *(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 200; |
|
406 TRAP(error, modify->SetTagL(EIfdExif, tag, buf->Des())); |
|
407 if(error != KErrArgument) |
|
408 { |
|
409 if(error) |
|
410 User::Leave(error); |
|
411 User::Leave(KErrGeneral); |
|
412 } |
|
413 CleanupStack::PopAndDestroy(buf); |
|
414 */ |
|
415 |
|
416 // Tag cannot be modified |
|
417 buf = TUtils::CreateDummyBufL(4); |
|
418 CleanupStack::PushL(buf); |
|
419 tag.iId = KIdExifIfdPointer; |
|
420 tag.iDataType = CExifTag::ETagAscii; |
|
421 tag.iDataCount = 4; |
|
422 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
423 if(error != KErrNotSupported) |
|
424 { |
|
425 if(error) |
|
426 User::Leave(error); |
|
427 User::Leave(KErrGeneral); |
|
428 } |
|
429 CleanupStack::PopAndDestroy(buf); |
|
430 buf = TUtils::CreateDummyBufL(4); |
|
431 CleanupStack::PushL(buf); |
|
432 tag.iId = KIdGpsIfdPointer; |
|
433 tag.iDataType = CExifTag::ETagAscii; |
|
434 tag.iDataCount = 4; |
|
435 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
436 if(error != KErrNotSupported) |
|
437 { |
|
438 if(error) |
|
439 User::Leave(error); |
|
440 User::Leave(KErrGeneral); |
|
441 } |
|
442 CleanupStack::PopAndDestroy(buf); |
|
443 buf = TUtils::CreateDummyBufL(4); |
|
444 CleanupStack::PushL(buf); |
|
445 tag.iId = KIdIntOpIfdPointer; |
|
446 tag.iDataType = CExifTag::ETagAscii; |
|
447 tag.iDataCount = 4; |
|
448 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
449 if(error != KErrNotSupported) |
|
450 { |
|
451 if(error) |
|
452 User::Leave(error); |
|
453 User::Leave(KErrGeneral); |
|
454 } |
|
455 CleanupStack::PopAndDestroy(buf); |
|
456 buf = TUtils::CreateDummyBufL(4); |
|
457 CleanupStack::PushL(buf); |
|
458 tag.iId = KIdJpegInterchangeFormat; |
|
459 tag.iDataType = CExifTag::ETagAscii; |
|
460 tag.iDataCount = 4; |
|
461 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
462 if(error != KErrNotSupported) |
|
463 { |
|
464 if(error) |
|
465 User::Leave(error); |
|
466 User::Leave(KErrGeneral); |
|
467 } |
|
468 CleanupStack::PopAndDestroy(buf); |
|
469 buf = TUtils::CreateDummyBufL(4); |
|
470 CleanupStack::PushL(buf); |
|
471 tag.iId = KIdJpegInterchangeFormatLength; |
|
472 tag.iDataType = CExifTag::ETagAscii; |
|
473 tag.iDataCount = 4; |
|
474 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
475 if(error != KErrNotSupported) |
|
476 { |
|
477 if(error) |
|
478 User::Leave(error); |
|
479 User::Leave(KErrGeneral); |
|
480 } |
|
481 CleanupStack::PopAndDestroy(buf); |
|
482 buf = TUtils::CreateDummyBufL(4); |
|
483 CleanupStack::PushL(buf); |
|
484 tag.iId = KIdExifVersion; |
|
485 tag.iDataType = CExifTag::ETagAscii; |
|
486 tag.iDataCount = 4; |
|
487 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
488 if(error != KErrNotSupported) |
|
489 { |
|
490 if(error) |
|
491 User::Leave(error); |
|
492 User::Leave(KErrGeneral); |
|
493 } |
|
494 CleanupStack::PopAndDestroy(buf); |
|
495 buf = TUtils::CreateDummyBufL(4); |
|
496 CleanupStack::PushL(buf); |
|
497 tag.iId = KIdGpsVersion; |
|
498 tag.iDataType = CExifTag::ETagAscii; |
|
499 tag.iDataCount = 4; |
|
500 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
501 if(error != KErrNotSupported) |
|
502 { |
|
503 if(error) |
|
504 User::Leave(error); |
|
505 User::Leave(KErrGeneral); |
|
506 } |
|
507 CleanupStack::PopAndDestroy(buf); |
|
508 buf = TUtils::CreateDummyBufL(4); |
|
509 CleanupStack::PushL(buf); |
|
510 tag.iId = KIdFlashPixVersion; |
|
511 tag.iDataType = CExifTag::ETagAscii; |
|
512 tag.iDataCount = 4; |
|
513 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
514 if(error != KErrNotSupported) |
|
515 { |
|
516 if(error) |
|
517 User::Leave(error); |
|
518 User::Leave(KErrGeneral); |
|
519 } |
|
520 CleanupStack::PopAndDestroy(buf); |
|
521 buf = TUtils::CreateDummyBufL(4); |
|
522 CleanupStack::PushL(buf); |
|
523 tag.iId = KIdCompression; |
|
524 tag.iDataType = CExifTag::ETagAscii; |
|
525 tag.iDataCount = 4; |
|
526 TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des())); |
|
527 if(error != KErrNotSupported) |
|
528 { |
|
529 if(error) |
|
530 User::Leave(error); |
|
531 User::Leave(KErrGeneral); |
|
532 } |
|
533 CleanupStack::PopAndDestroy(buf); |
|
534 |
|
535 |
|
536 CleanupStack::PopAndDestroy(modify); |
|
537 |
|
538 } |
|
539 |
|
540 // Exif.Modify.06 |
|
541 // Remove a tag from the specified IFD in Exif data. |
|
542 // Removes the tag from the specified IFD. |
|
543 void CExifModifyTest2::ExifModify006L() |
|
544 { |
|
545 // For each IFD. |
|
546 |
|
547 |
|
548 CExifModify* modify = CExifModify::NewL(); |
|
549 CleanupStack::PushL(modify); |
|
550 |
|
551 modify->SetXResolutionL( 72, 1 ); |
|
552 |
|
553 modify->SetExposureProgramL( 1 ); |
|
554 |
|
555 modify->SetThumbnailResolutionUnitL( 2 ); |
|
556 |
|
557 |
|
558 User::LeaveIfError(modify->DeleteTag(EIfd1, KIdResolutionUnit)); |
|
559 |
|
560 User::LeaveIfError(modify->DeleteTag(EIfd0, KIdXResolution)); |
|
561 |
|
562 User::LeaveIfError(modify->DeleteTag(EIfdExif, KIdExposureProgram)); |
|
563 |
|
564 CleanupStack::PopAndDestroy(modify); |
|
565 |
|
566 } |
|
567 |
|
568 // Exif.Modify.07 |
|
569 // Try to remove a tag from the specified IFD in Exif data. |
|
570 // Returns proper error code. |
|
571 void CExifModifyTest2::ExifModify007L() |
|
572 { |
|
573 //"For each IFD; |
|
574 //* IFD exists but tag doesn't exist, |
|
575 //* IFD doesn't exist" |
|
576 |
|
577 |
|
578 |
|
579 CExifModify* modify = CExifModify::NewL(); |
|
580 CleanupStack::PushL(modify); |
|
581 TInt error = modify->DeleteTag(EIfd0, 0x013f); |
|
582 if(error != KErrNotFound) |
|
583 { |
|
584 if(error) |
|
585 { |
|
586 User::Leave(error); |
|
587 } |
|
588 User::Leave(KErrGeneral); |
|
589 } |
|
590 |
|
591 error = modify->DeleteTag(EIfdExif, KIdMakerNote); |
|
592 if(error != KErrNotFound) |
|
593 { |
|
594 if(error) |
|
595 { |
|
596 User::Leave(error); |
|
597 } |
|
598 User::Leave(KErrGeneral); |
|
599 } |
|
600 |
|
601 error = modify->DeleteTag(EIfd1, KIdCompression); |
|
602 if(error != KErrNotSupported) |
|
603 { |
|
604 if(error) |
|
605 { |
|
606 User::Leave(error); |
|
607 } |
|
608 User::Leave(KErrGeneral); |
|
609 } |
|
610 |
|
611 error = modify->DeleteTag(EIfdIntOp, 4); |
|
612 if(error != KErrNotFound) |
|
613 { |
|
614 if(error) |
|
615 { |
|
616 User::Leave(error); |
|
617 } |
|
618 User::Leave(KErrGeneral); |
|
619 } |
|
620 |
|
621 error = modify->DeleteTag(EIfdGps, 27); |
|
622 if(error != KErrNotFound) |
|
623 { |
|
624 if(error) |
|
625 { |
|
626 User::Leave(error); |
|
627 } |
|
628 User::Leave(KErrGeneral); |
|
629 } |
|
630 |
|
631 //* Invalid tag ID |
|
632 error = modify->DeleteTag(EIfdExif, 0x0205); |
|
633 if(error != KErrNotSupported) |
|
634 { |
|
635 if(error) |
|
636 { |
|
637 User::Leave(error); |
|
638 } |
|
639 User::Leave(KErrGeneral); |
|
640 } |
|
641 |
|
642 //* Tag cannot be removed! |
|
643 error = modify->DeleteTag(EIfdExif, KIdGpsIfdPointer); |
|
644 if(error != KErrNotSupported) |
|
645 { |
|
646 if(error) |
|
647 { |
|
648 User::Leave(error); |
|
649 } |
|
650 User::Leave(KErrGeneral); |
|
651 } |
|
652 error = modify->DeleteTag(EIfdExif, KIdFlashPixVersion); |
|
653 if(error != KErrNotSupported) |
|
654 { |
|
655 if(error) |
|
656 { |
|
657 User::Leave(error); |
|
658 } |
|
659 User::Leave(KErrGeneral); |
|
660 } |
|
661 error = modify->DeleteTag(EIfdExif, KIdExifIfdPointer); |
|
662 if(error != KErrNotSupported) |
|
663 { |
|
664 if(error) |
|
665 { |
|
666 User::Leave(error); |
|
667 } |
|
668 User::Leave(KErrGeneral); |
|
669 } |
|
670 error = modify->DeleteTag(EIfdExif, KIdIntOpIfdPointer); |
|
671 if(error != KErrNotSupported) |
|
672 { |
|
673 if(error) |
|
674 { |
|
675 User::Leave(error); |
|
676 } |
|
677 User::Leave(KErrGeneral); |
|
678 } |
|
679 error = modify->DeleteTag(EIfdExif, KIdJpegInterchangeFormat); |
|
680 if(error != KErrNotSupported) |
|
681 { |
|
682 if(error) |
|
683 { |
|
684 User::Leave(error); |
|
685 } |
|
686 User::Leave(KErrGeneral); |
|
687 } |
|
688 error = modify->DeleteTag(EIfdExif, KIdGpsVersion); |
|
689 if(error != KErrNotSupported) |
|
690 { |
|
691 if(error) |
|
692 { |
|
693 User::Leave(error); |
|
694 } |
|
695 User::Leave(KErrGeneral); |
|
696 } |
|
697 error = modify->DeleteTag(EIfdExif, KIdJpegInterchangeFormatLength); |
|
698 if(error != KErrNotSupported) |
|
699 { |
|
700 if(error) |
|
701 { |
|
702 User::Leave(error); |
|
703 } |
|
704 User::Leave(KErrGeneral); |
|
705 } |
|
706 error = modify->DeleteTag(EIfdExif, KIdExifVersion); |
|
707 if(error != KErrNotSupported) |
|
708 { |
|
709 if(error) |
|
710 { |
|
711 User::Leave(error); |
|
712 } |
|
713 User::Leave(KErrGeneral); |
|
714 } |
|
715 CleanupStack::PopAndDestroy(modify); |
|
716 |
|
717 } |
|
718 |
|
719 // Exif.Modify.08 |
|
720 // Remove an IFD from the Exif data. |
|
721 // Removes the IFD from the Exif data. |
|
722 void CExifModifyTest2::ExifModify008L() |
|
723 { |
|
724 // For each IFD. |
|
725 |
|
726 |
|
727 CExifModify* modify = CExifModify::NewL(); |
|
728 CleanupStack::PushL(modify); |
|
729 |
|
730 // Not allowed to delete Ifd0 and ExifIfd |
|
731 // User::LeaveIfError(modify->DeleteIfd(EIfd0)); |
|
732 // User::LeaveIfError(modify->DeleteIfd(EIfdExif)); |
|
733 TExifTagInfo tag( 3, CExifTag::ETagAscii, 1 ); |
|
734 HBufC8* buf = TUtils::CreateDummyBufL(1); |
|
735 CleanupStack::PushL(buf); |
|
736 modify->SetTagL(EIfdGps, tag, buf->Des()); |
|
737 CleanupStack::PopAndDestroy(buf); |
|
738 |
|
739 buf = TUtils::CreateDummyBufL(3); |
|
740 CleanupStack::PushL(buf); |
|
741 tag.iId = 1; |
|
742 tag.iDataType = CExifTag::ETagAscii; |
|
743 tag.iDataCount = 3; |
|
744 modify->SetTagL(EIfdIntOp, tag, buf->Des()); |
|
745 CleanupStack::PopAndDestroy(buf); |
|
746 |
|
747 modify->SetThumbnailResolutionUnitL( 2 ); |
|
748 |
|
749 User::LeaveIfError(modify->DeleteIfd(EIfd1)); |
|
750 User::LeaveIfError(modify->DeleteIfd(EIfdGps)); |
|
751 User::LeaveIfError(modify->DeleteIfd(EIfdIntOp)); |
|
752 |
|
753 CleanupStack::PopAndDestroy(modify); |
|
754 |
|
755 } |
|
756 |
|
757 // Exif.Modify.09 |
|
758 // Try to remove an IFD from the Exif data, which doesn't contain that IFD. |
|
759 // Returns proper error code. |
|
760 void CExifModifyTest2::ExifModify009L() |
|
761 { |
|
762 // For each IFD. |
|
763 |
|
764 |
|
765 CExifModify* modify = CExifModify::NewL(); |
|
766 CleanupStack::PushL(modify); |
|
767 TInt error = modify->DeleteIfd(EIfdGps); |
|
768 |
|
769 if(error != KErrNotFound) |
|
770 { |
|
771 if(error) |
|
772 { |
|
773 User::Leave(error); |
|
774 } |
|
775 User::Leave(KErrGeneral); |
|
776 } |
|
777 |
|
778 error = modify->DeleteIfd(EIfd0); |
|
779 if(error != KErrArgument) |
|
780 { |
|
781 if(error) |
|
782 { |
|
783 User::Leave(error); |
|
784 } |
|
785 User::Leave(KErrGeneral); |
|
786 } |
|
787 |
|
788 // IFD cannot be removed |
|
789 error = modify->DeleteIfd(EIfd0); |
|
790 if( error != KErrArgument) |
|
791 { |
|
792 if(error) |
|
793 { |
|
794 User::Leave(error); |
|
795 } |
|
796 User::Leave(KErrGeneral); |
|
797 } |
|
798 |
|
799 error = modify->DeleteIfd(EIfdExif); |
|
800 if( error != KErrArgument) |
|
801 { |
|
802 if(error) |
|
803 { |
|
804 User::Leave(error); |
|
805 } |
|
806 User::Leave(KErrGeneral); |
|
807 } |
|
808 CleanupStack::PopAndDestroy(modify); |
|
809 |
|
810 } |
|
811 |
|
812 // Exif.Modify.010 |
|
813 // Insert/ Update compressed Exif thumbnail image into the the Exif data. |
|
814 // Inserts/ Updates the Exif thumbnail image |
|
815 void CExifModifyTest2::ExifModify010L() |
|
816 { |
|
817 |
|
818 CExifModify* modify = CExifModify::NewL(); |
|
819 CleanupStack::PushL(modify); |
|
820 |
|
821 HBufC8* thumbnail = TUtils::ReadFileL(iFs, KValidThumbnail); |
|
822 CleanupStack::PushL(thumbnail); |
|
823 modify->SetThumbnailL(thumbnail->Des()); |
|
824 CleanupStack::PopAndDestroy(thumbnail); |
|
825 |
|
826 CleanupStack::PopAndDestroy(modify); |
|
827 |
|
828 } |
|
829 |
|
830 // Exif.Modify.011 |
|
831 // Try to Insert/ Update compressed Exif thumbnail image with in invalid cases. |
|
832 // Leaves with proper error code. |
|
833 void CExifModifyTest2::ExifModify011L() |
|
834 { |
|
835 |
|
836 |
|
837 CExifModify* modify = CExifModify::NewL(); |
|
838 CleanupStack::PushL(modify); |
|
839 |
|
840 //"* Given thumbnail data is not valid compressed Exif thumbnail image, !! Not supported yet !! |
|
841 HBufC8* buf = TUtils::CreateDummyBufL(8000); |
|
842 CleanupStack::PushL(buf); |
|
843 TRAPD( error, modify->SetThumbnailL(buf->Des()) ); |
|
844 if ( error != KErrCorrupt ) |
|
845 { |
|
846 if ( error ) |
|
847 { |
|
848 User::Leave( error ); |
|
849 } |
|
850 User::Leave( KErrGeneral ); |
|
851 } |
|
852 CleanupStack::PopAndDestroy( buf ); |
|
853 |
|
854 //* The Exif data size exceeds 64K" |
|
855 TExifTagInfo tag(KIdImageDescription, CExifTag::ETagAscii, 59000); |
|
856 buf = TUtils::CreateDummyBufL(59000); |
|
857 CleanupStack::PushL(buf); |
|
858 modify->SetTagL(EIfd0, tag, buf->Des()); |
|
859 CleanupStack::PopAndDestroy(buf); |
|
860 |
|
861 HBufC8* thumbnail = TUtils::ReadFileL(iFs, KValidThumbnail); |
|
862 CleanupStack::PushL(thumbnail); |
|
863 TRAP( error, modify->SetThumbnailL(thumbnail->Des()) ); |
|
864 if ( error != KErrOverflow ) |
|
865 { |
|
866 if ( error ) |
|
867 { |
|
868 User::Leave( error ); |
|
869 } |
|
870 User::Leave( KErrGeneral ); |
|
871 } |
|
872 CleanupStack::PopAndDestroy(thumbnail); |
|
873 |
|
874 CleanupStack::PopAndDestroy(modify); |
|
875 |
|
876 } |
|
877 |
|
878 // Exif.Modify.012 |
|
879 // Remove compressed Exif thumbnail image from the Exif data. |
|
880 // Removes the thumbnail image. |
|
881 void CExifModifyTest2::ExifModify012L() |
|
882 { |
|
883 |
|
884 |
|
885 CExifModify* modify = CExifModify::NewL(); |
|
886 CleanupStack::PushL(modify); |
|
887 |
|
888 HBufC8* thumbnail = TUtils::ReadFileL(iFs, KValidThumbnail); |
|
889 CleanupStack::PushL(thumbnail); |
|
890 modify->SetThumbnailL(thumbnail->Des()); |
|
891 |
|
892 User::LeaveIfError(modify->RemoveThumbnail()); |
|
893 |
|
894 CleanupStack::PopAndDestroy( thumbnail ); |
|
895 |
|
896 CleanupStack::PopAndDestroy(modify); |
|
897 |
|
898 } |
|
899 |
|
900 // Exif.Modify.013 |
|
901 // Try to remove compressed Exif thumbnail image from the Exif data. |
|
902 // Returns proper error code. |
|
903 void CExifModifyTest2::ExifModify013L() |
|
904 { |
|
905 CExifModify* modify = CExifModify::NewL(); |
|
906 CleanupStack::PushL(modify); |
|
907 TInt error = modify->RemoveThumbnail(); |
|
908 |
|
909 if(error != KErrNotFound) |
|
910 { |
|
911 if(error) |
|
912 { |
|
913 User::Leave(error); |
|
914 } |
|
915 User::Leave(KErrGeneral); |
|
916 } |
|
917 |
|
918 |
|
919 CleanupStack::PopAndDestroy(modify); |
|
920 |
|
921 } |
|
922 |
|
923 // Exif.Modify.014 |
|
924 // Write the final Exif image to a buffer. |
|
925 // Writes the whole Exif image in a buffer, and returns the buffer. |
|
926 void CExifModifyTest2::ExifModify014L() |
|
927 { |
|
928 |
|
929 |
|
930 CExifModify* modify = CExifModify::NewL(); |
|
931 CleanupStack::PushL(modify); |
|
932 |
|
933 // Insert Tags |
|
934 HBufC8* buf = 0; |
|
935 TUint16 tmp1 = 0; |
|
936 TUint32 tmp3 = 0; |
|
937 TUint32 tmp4 = 0; |
|
938 TInt32 tmp5 = 0; |
|
939 TInt32 tmp6 = 0; |
|
940 |
|
941 buf = TUtils::CreateDummyBufL(10); |
|
942 CleanupStack::PushL(buf); |
|
943 modify->SetUserCommentL(buf->Des()); |
|
944 CleanupStack::PopAndDestroy(buf); |
|
945 buf = 0; |
|
946 |
|
947 buf = TUtils::CreateDummyBufL(4); |
|
948 CleanupStack::PushL(buf); |
|
949 modify->SetModelL(buf->Des()); |
|
950 CleanupStack::PopAndDestroy(buf); |
|
951 buf = 0; |
|
952 |
|
953 tmp1 = 0; |
|
954 modify->SetMeteringModeL(tmp1); |
|
955 |
|
956 tmp5 = 1; |
|
957 tmp6 = 1; |
|
958 modify->SetExposureBiasValueL(tmp5, tmp6); |
|
959 |
|
960 tmp5 = 0; |
|
961 tmp6 = 1; |
|
962 modify->SetShutterSpeedValueL(tmp5, tmp6); |
|
963 |
|
964 modify->SetBrightnessValueL(tmp5, tmp6); |
|
965 |
|
966 modify->SetCustomRenderedL(0); |
|
967 |
|
968 modify->SetGainControlL(0); |
|
969 |
|
970 buf = TUtils::CreateDummyBufL(19); |
|
971 CleanupStack::PushL(buf); |
|
972 buf->Des().Copy(_L("2004:01:19 11:00:00")); |
|
973 modify->SetDateTimeOriginalL(buf->Des()); |
|
974 modify->SetDateTimeDigitizedL(buf->Des()); |
|
975 CleanupStack::PopAndDestroy(buf); |
|
976 buf = 0; |
|
977 |
|
978 tmp5 = 1; |
|
979 tmp6 = 1; |
|
980 modify->SetApertureValueL(tmp5, tmp6); |
|
981 |
|
982 tmp3 = 72; |
|
983 tmp4 = 1; |
|
984 modify->SetXResolutionL(tmp3, tmp4); |
|
985 modify->SetYResolutionL(tmp3, tmp4); |
|
986 tmp1 = 2; |
|
987 modify->SetResolutionUnitL(tmp1); |
|
988 tmp1 = 1; |
|
989 modify->SetYCbCrPositioningL(tmp1); |
|
990 |
|
991 modify->SetComponentsConfigurationL(1, 2, 3, 0); |
|
992 tmp1 = 1; |
|
993 modify->SetColorSpaceL(tmp1); |
|
994 tmp3 = 1024; |
|
995 modify->SetPixelXDimensionL(tmp3); |
|
996 tmp3 = 768; |
|
997 modify->SetPixelYDimensionL(tmp3); |
|
998 |
|
999 |
|
1000 buf = TUtils::CreateDummyBufL(5); |
|
1001 CleanupStack::PushL(buf); |
|
1002 modify->SetImageDescriptionL(buf->Des()); |
|
1003 CleanupStack::PopAndDestroy(buf); |
|
1004 buf = 0; |
|
1005 |
|
1006 |
|
1007 buf = TUtils::CreateDummyBufL(768*2); |
|
1008 CleanupStack::PushL(buf); |
|
1009 modify->SetTransferFunctionL(buf->Des()); |
|
1010 CleanupStack::PopAndDestroy(buf); |
|
1011 buf = 0; |
|
1012 |
|
1013 modify->SetExposureModeL(0); |
|
1014 modify->SetWhiteBalanceL(0); |
|
1015 modify->SetSceneCaptureTypeL(0); |
|
1016 modify->SetExposureProgramL(0); |
|
1017 |
|
1018 modify->SetLightSourceL(0); |
|
1019 |
|
1020 buf = TUtils::CreateDummyBufL(16); |
|
1021 CleanupStack::PushL(buf); |
|
1022 modify->SetMakerNoteL(buf->Des()); |
|
1023 CleanupStack::PopAndDestroy(buf); |
|
1024 buf = 0; |
|
1025 |
|
1026 TPtrC8 tmpDes; |
|
1027 HBufC8* buffer = modify->WriteDataL( tmpDes ); |
|
1028 if(!buffer) |
|
1029 User::Leave(KErrGeneral); |
|
1030 delete buffer; |
|
1031 buffer = 0; |
|
1032 |
|
1033 HBufC8* exif = TUtils::ReadFileL(iFs, KValidJpeg); |
|
1034 CleanupStack::PushL(exif); |
|
1035 buffer = modify->WriteDataL( exif->Des() ); |
|
1036 if(!buffer) |
|
1037 User::Leave(KErrGeneral); |
|
1038 delete buffer; |
|
1039 CleanupStack::PopAndDestroy( exif ); |
|
1040 |
|
1041 CleanupStack::PopAndDestroy(modify); |
|
1042 |
|
1043 } |
|
1044 |
|
1045 |
|
1046 // Exif.Modify.015 |
|
1047 // Try to write the final Exif image to a buffer for invalid cases or incorrect original data buffer |
|
1048 // Leaves with proper error code. |
|
1049 void CExifModifyTest2::ExifModify015L() |
|
1050 { |
|
1051 |
|
1052 |
|
1053 CExifModify* modify = CExifModify::NewL(); |
|
1054 CleanupStack::PushL(modify); |
|
1055 |
|
1056 //"* Given buffer content is not the same with the original buffer content. |
|
1057 TInt error = 0; |
|
1058 HBufC8* buf = 0; |
|
1059 HBufC8* buffer = 0; |
|
1060 |
|
1061 //* The Exif data doesn't contain all mandatory tags" |
|
1062 |
|
1063 // Insert Tags |
|
1064 TUint16 tmp1 = 0; |
|
1065 TUint32 tmp3 = 0; |
|
1066 TUint32 tmp4 = 0; |
|
1067 |
|
1068 tmp3 = 72; |
|
1069 tmp4 = 1; |
|
1070 modify->SetXResolutionL(tmp3, tmp4); |
|
1071 tmp1 = 2; |
|
1072 modify->SetResolutionUnitL(tmp1); |
|
1073 |
|
1074 modify->SetComponentsConfigurationL(1, 2, 3, 0); |
|
1075 tmp1 = 1; |
|
1076 modify->SetColorSpaceL(tmp1); |
|
1077 tmp3 = 768; |
|
1078 modify->SetPixelYDimensionL(tmp3); |
|
1079 modify->DeleteTag(EIfdExif, KIdPixelXDimension); |
|
1080 |
|
1081 |
|
1082 buf = TUtils::CreateDummyBufL(5); |
|
1083 CleanupStack::PushL(buf); |
|
1084 modify->SetImageDescriptionL(buf->Des()); |
|
1085 CleanupStack::PopAndDestroy(buf); |
|
1086 buf = 0; |
|
1087 |
|
1088 |
|
1089 buf = TUtils::CreateDummyBufL(768*2); |
|
1090 CleanupStack::PushL(buf); |
|
1091 modify->SetTransferFunctionL(buf->Des()); |
|
1092 CleanupStack::PopAndDestroy(buf); |
|
1093 buf = 0; |
|
1094 |
|
1095 modify->SetExposureModeL(0); |
|
1096 modify->SetWhiteBalanceL(0); |
|
1097 modify->SetSceneCaptureTypeL(0); |
|
1098 modify->SetExposureProgramL(0); |
|
1099 |
|
1100 modify->SetLightSourceL(0); |
|
1101 |
|
1102 buf = TUtils::CreateDummyBufL(16); |
|
1103 CleanupStack::PushL(buf); |
|
1104 modify->SetMakerNoteL(buf->Des()); |
|
1105 CleanupStack::PopAndDestroy(buf); |
|
1106 buf = 0; |
|
1107 |
|
1108 buffer = 0; |
|
1109 TPtrC8 tmpDes; |
|
1110 TRAP(error, modify->WriteDataL( tmpDes )); |
|
1111 if(buffer) |
|
1112 { |
|
1113 delete buffer; |
|
1114 User::Leave(KErrGeneral); |
|
1115 } |
|
1116 if(error != KErrNotReady) |
|
1117 { |
|
1118 if(error) |
|
1119 User::Leave(error); |
|
1120 User::Leave(KErrGeneral); |
|
1121 } |
|
1122 |
|
1123 CleanupStack::PopAndDestroy(modify); |
|
1124 |
|
1125 } |
|
1126 |
|
1127 // Exif.Modify.016 |
|
1128 // Test the behavior of the previous test cases after the Exif image is written into a buffer (WriteDataL) called. |
|
1129 // Leaves with or returns proper error code. |
|
1130 // CHANGED: |
|
1131 // This feature is changed. Multiple usage is allowed any more. Test using the modifier after WriteDataL function. |
|
1132 void CExifModifyTest2::ExifModify016L() |
|
1133 { |
|
1134 CExifModify* modify = CExifModify::NewL(); |
|
1135 CleanupStack::PushL(modify); |
|
1136 |
|
1137 HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg); |
|
1138 CleanupStack::PushL(jpeg); |
|
1139 |
|
1140 // Insert Tags |
|
1141 TUint16 tmp1 = 0; |
|
1142 TUint32 tmp3 = 0; |
|
1143 TUint32 tmp4 = 0; |
|
1144 |
|
1145 modify->SetYCbCrPositioningL(2); |
|
1146 modify->SetComponentsConfigurationL(1, 2, 3, 0); |
|
1147 tmp1 = 1; |
|
1148 modify->SetColorSpaceL(tmp1); |
|
1149 tmp3 = 480; |
|
1150 modify->SetPixelYDimensionL(tmp3); |
|
1151 |
|
1152 tmp3 = 72; |
|
1153 tmp4 = 1; |
|
1154 modify->SetXResolutionL(tmp3, tmp4); |
|
1155 modify->SetYResolutionL(tmp3, tmp4); |
|
1156 tmp1 = 2; |
|
1157 modify->SetResolutionUnitL(tmp1); |
|
1158 |
|
1159 HBufC8* buffer = NULL; |
|
1160 TPtrC8 tmpDes; |
|
1161 TRAPD( error, buffer = modify->WriteDataL( tmpDes ) ); |
|
1162 if( (error != KErrNotReady) || (buffer) ) |
|
1163 { |
|
1164 if( buffer ) |
|
1165 delete buffer; |
|
1166 buffer = 0; |
|
1167 if( error ) |
|
1168 { |
|
1169 User::Leave( error); |
|
1170 } |
|
1171 User::Leave( KErrGeneral ); |
|
1172 } |
|
1173 |
|
1174 TRAP( error, buffer = modify->WriteDataL( jpeg->Des() ) ); |
|
1175 if( (error != KErrNotReady) || (buffer) ) |
|
1176 { |
|
1177 if( buffer ) |
|
1178 delete buffer; |
|
1179 buffer = 0; |
|
1180 if( error ) |
|
1181 { |
|
1182 User::Leave( error); |
|
1183 } |
|
1184 User::Leave( KErrGeneral ); |
|
1185 } |
|
1186 |
|
1187 modify->SetPixelXDimensionL(640); |
|
1188 |
|
1189 TRAP( error, buffer = modify->WriteDataL( tmpDes ) ); |
|
1190 if( (error != KErrNone) || (!buffer) ) |
|
1191 { |
|
1192 if( buffer ) |
|
1193 delete buffer; |
|
1194 buffer = 0; |
|
1195 if( error ) |
|
1196 { |
|
1197 User::Leave( error); |
|
1198 } |
|
1199 User::Leave( KErrGeneral ); |
|
1200 } |
|
1201 delete buffer; |
|
1202 buffer = 0; |
|
1203 |
|
1204 TRAP( error, buffer = modify->WriteDataL( jpeg->Des() ) ); |
|
1205 if( (error != KErrNone) || (!buffer) ) |
|
1206 { |
|
1207 if( buffer ) |
|
1208 delete buffer; |
|
1209 buffer = 0; |
|
1210 if( error ) |
|
1211 { |
|
1212 User::Leave( error); |
|
1213 } |
|
1214 User::Leave( KErrGeneral ); |
|
1215 } |
|
1216 CleanupStack::PushL(buffer); |
|
1217 |
|
1218 RFile file; |
|
1219 TBuf<255> fileName; |
|
1220 fileName.Copy(KRootOut); |
|
1221 fileName.Append(_L("out\\")); |
|
1222 fileName.Append(_L("Modify216_01.jpg")); |
|
1223 if(file.Open(iFs, fileName, EFileWrite) != KErrNone) |
|
1224 { |
|
1225 if(file.Create(iFs, fileName, EFileWrite) != KErrNone) |
|
1226 { |
|
1227 fileName.Copy(KRootC); |
|
1228 fileName.Append(_L("out\\")); |
|
1229 fileName.Append(_L("Modify216_01.jpg")); |
|
1230 if(file.Open(iFs, fileName, EFileWrite) != KErrNone) |
|
1231 { |
|
1232 if(file.Create(iFs, fileName, EFileWrite) != KErrNone) |
|
1233 { |
|
1234 fileName.Copy(KRootData); |
|
1235 fileName.Append(_L("out\\")); |
|
1236 fileName.Append(_L("Modify216_01.jpg")); |
|
1237 if(file.Open(iFs, fileName, EFileWrite) != KErrNone) |
|
1238 { |
|
1239 User::LeaveIfError(file.Create(iFs, fileName, EFileWrite)); |
|
1240 } |
|
1241 } |
|
1242 } |
|
1243 } |
|
1244 } |
|
1245 |
|
1246 file.Write(buffer->Des()); |
|
1247 file.Close(); |
|
1248 |
|
1249 CleanupStack::PopAndDestroy(buffer); |
|
1250 buffer = 0; |
|
1251 |
|
1252 |
|
1253 TRAP( error, buffer = modify->WriteDataL( tmpDes ) ); |
|
1254 if( (error != KErrNone) || (!buffer) ) |
|
1255 { |
|
1256 if( buffer ) |
|
1257 delete buffer; |
|
1258 buffer = 0; |
|
1259 if( error ) |
|
1260 { |
|
1261 User::Leave( error); |
|
1262 } |
|
1263 User::Leave( KErrGeneral ); |
|
1264 } |
|
1265 delete buffer; |
|
1266 buffer = 0; |
|
1267 |
|
1268 TRAP( error, buffer = modify->WriteDataL( jpeg->Des() ) ); |
|
1269 if( (error != KErrNone) || (!buffer) ) |
|
1270 { |
|
1271 if( buffer ) |
|
1272 delete buffer; |
|
1273 buffer = 0; |
|
1274 if( error ) |
|
1275 { |
|
1276 User::Leave( error); |
|
1277 } |
|
1278 User::Leave( KErrGeneral ); |
|
1279 } |
|
1280 CleanupStack::PushL(buffer); |
|
1281 |
|
1282 fileName.Copy(KRootOut); |
|
1283 fileName.Append(_L("out\\")); |
|
1284 fileName.Append(_L("Modify216_02.jpg")); |
|
1285 if(file.Open(iFs, fileName, EFileWrite) != KErrNone) |
|
1286 { |
|
1287 if(file.Create(iFs, fileName, EFileWrite) != KErrNone) |
|
1288 { |
|
1289 fileName.Copy(KRootC); |
|
1290 fileName.Append(_L("out\\")); |
|
1291 fileName.Append(_L("Modify216_02.jpg")); |
|
1292 if(file.Open(iFs, fileName, EFileWrite) != KErrNone) |
|
1293 { |
|
1294 if(file.Create(iFs, fileName, EFileWrite) != KErrNone) |
|
1295 { |
|
1296 fileName.Copy(KRootData); |
|
1297 fileName.Append(_L("out\\")); |
|
1298 fileName.Append(_L("Modify216_02.jpg")); |
|
1299 if(file.Open(iFs, fileName, EFileWrite) != KErrNone) |
|
1300 { |
|
1301 User::LeaveIfError(file.Create(iFs, fileName, EFileWrite)); |
|
1302 } |
|
1303 } |
|
1304 } |
|
1305 } |
|
1306 } |
|
1307 |
|
1308 file.Write(buffer->Des()); |
|
1309 file.Close(); |
|
1310 CleanupStack::PopAndDestroy(buffer); |
|
1311 buffer = 0; |
|
1312 |
|
1313 modify->DeleteTag(EIfdExif, KIdPixelXDimension); |
|
1314 |
|
1315 TRAP( error, buffer = modify->WriteDataL( jpeg->Des() ) ); |
|
1316 if( (error != KErrNotReady) || (buffer) ) |
|
1317 { |
|
1318 if( buffer ) |
|
1319 delete buffer; |
|
1320 buffer = 0; |
|
1321 if( error ) |
|
1322 { |
|
1323 User::Leave( error); |
|
1324 } |
|
1325 User::Leave( KErrGeneral ); |
|
1326 } |
|
1327 |
|
1328 TRAP( error, buffer = modify->WriteDataL( tmpDes ) ); |
|
1329 if( (error != KErrNotReady) || (buffer) ) |
|
1330 { |
|
1331 if( buffer ) |
|
1332 delete buffer; |
|
1333 buffer = 0; |
|
1334 if( error ) |
|
1335 { |
|
1336 User::Leave( error); |
|
1337 } |
|
1338 User::Leave( KErrGeneral ); |
|
1339 } |
|
1340 |
|
1341 CleanupStack::PopAndDestroy( jpeg ); |
|
1342 CleanupStack::PopAndDestroy(modify); |
|
1343 |
|
1344 } |
|
1345 |
|
1346 // Exif.Modify.018 |
|
1347 // Try to retrieve the Exif APP1 segment when the Exif is not complete yet. |
|
1348 // Leaves with KErrNotReady. |
|
1349 void CExifModifyTest2::ExifModify018L() |
|
1350 { |
|
1351 |
|
1352 |
|
1353 CExifModify* modify = CExifModify::NewL( ); |
|
1354 CleanupStack::PushL( modify ); |
|
1355 |
|
1356 modify->DeleteTag( EIfd0, KIdXResolution ); |
|
1357 HBufC8* appSegment = 0; |
|
1358 TRAPD( error, appSegment = modify->Reader()->GetExifAppSegmentL() ); |
|
1359 if ( (error != KErrNotReady) || ( appSegment ) ) |
|
1360 { |
|
1361 if ( appSegment ) |
|
1362 delete appSegment; |
|
1363 if ( error == KErrNoMemory ) |
|
1364 { |
|
1365 User::Leave( error ); |
|
1366 } |
|
1367 User::Leave( KErrGeneral ); |
|
1368 } |
|
1369 |
|
1370 CleanupStack::PopAndDestroy( modify ); |
|
1371 } |
|
1372 |
|
1373 // Exif.Modify.019 |
|
1374 // Check NULL character at the end of ASCII type tags |
|
1375 // Returns error for invalid cases and behaves properly for other cases. |
|
1376 void CExifModifyTest2::ExifModify019L() |
|
1377 { |
|
1378 |
|
1379 |
|
1380 CExifModify* modify = CExifModify::NewL( ); |
|
1381 CleanupStack::PushL( modify ); |
|
1382 |
|
1383 HBufC8* buf = TUtils::CreateDummyBufL(19); |
|
1384 CleanupStack::PushL(buf); |
|
1385 buf->Des().Copy(_L("2004:01:19 11:00:00")); |
|
1386 modify->SetDateTimeOriginalL(buf->Des()); |
|
1387 CleanupStack::PopAndDestroy(buf); |
|
1388 buf = 0; |
|
1389 buf = modify->Reader()->GetDateTimeOriginalL(); |
|
1390 CleanupStack::PushL(buf); |
|
1391 if ( ( buf->Des().Ptr()[buf->Des().Length() - 1] != NULL ) && |
|
1392 ( buf->Des().Length() != 20 ) ) |
|
1393 { |
|
1394 User::Leave( KErrGeneral ); |
|
1395 } |
|
1396 CleanupStack::PopAndDestroy(buf); |
|
1397 buf = 0; |
|
1398 |
|
1399 buf = TUtils::CreateDummyBufL(20); |
|
1400 CleanupStack::PushL(buf); |
|
1401 buf->Des().Copy(_L("2004:01:19 11:00:00\0")); |
|
1402 modify->SetDateTimeOriginalL(buf->Des()); |
|
1403 CleanupStack::PopAndDestroy(buf); |
|
1404 buf = 0; |
|
1405 buf = modify->Reader()->GetDateTimeOriginalL(); |
|
1406 CleanupStack::PushL(buf); |
|
1407 if ( ( buf->Des().Ptr()[buf->Des().Length() - 1] != NULL ) && |
|
1408 ( buf->Des().Length() != 20 ) ) |
|
1409 { |
|
1410 User::Leave( KErrGeneral ); |
|
1411 } |
|
1412 CleanupStack::PopAndDestroy(buf); |
|
1413 buf = 0; |
|
1414 |
|
1415 buf = TUtils::CreateDummyBufL(18); |
|
1416 CleanupStack::PushL(buf); |
|
1417 buf->Des().Copy(_L("2004:01:19 11:00:0")); |
|
1418 TRAPD( error, modify->SetDateTimeOriginalL(buf->Des()) ); |
|
1419 if ( error != KErrNotSupported ) |
|
1420 { |
|
1421 User::LeaveIfError( error ); |
|
1422 User::Leave( KErrGeneral ); |
|
1423 } |
|
1424 CleanupStack::PopAndDestroy(buf); |
|
1425 buf = 0; |
|
1426 |
|
1427 buf = TUtils::CreateDummyBufL(20); |
|
1428 CleanupStack::PushL(buf); |
|
1429 buf->Des().Copy(_L("2004:01:19 11:00:001")); |
|
1430 TRAP( error, modify->SetDateTimeOriginalL(buf->Des()) ); |
|
1431 if ( error != KErrNotSupported ) |
|
1432 { |
|
1433 User::LeaveIfError( error ); |
|
1434 User::Leave( KErrGeneral ); |
|
1435 } |
|
1436 CleanupStack::PopAndDestroy(buf); |
|
1437 buf = 0; |
|
1438 |
|
1439 buf = TUtils::CreateDummyBufL(12); |
|
1440 CleanupStack::PushL(buf); |
|
1441 TExifTagInfo tag(KIdRelatedSoundFile, CExifTag::ETagAscii, 12); |
|
1442 modify->SetTagL(EIfdExif, tag, buf->Des()); |
|
1443 CleanupStack::PopAndDestroy(buf); |
|
1444 buf = modify->Reader()->GetRelatedSoundFileL(); |
|
1445 CleanupStack::PushL(buf); |
|
1446 if ( ( buf->Des().Ptr()[buf->Des().Length() - 1] != NULL ) && |
|
1447 ( buf->Des().Length() != 13 ) ) |
|
1448 { |
|
1449 User::Leave( KErrGeneral ); |
|
1450 } |
|
1451 CleanupStack::PopAndDestroy(buf); |
|
1452 buf = 0; |
|
1453 |
|
1454 buf = TUtils::CreateDummyBufL(13); |
|
1455 CleanupStack::PushL(buf); |
|
1456 TExifTagInfo tag2(KIdRelatedSoundFile, CExifTag::ETagAscii, 13); |
|
1457 *( CONST_CAST( TUint8*, buf->Des().Ptr()) + 12 ) = NULL; |
|
1458 modify->SetTagL(EIfdExif, tag2, buf->Des()); |
|
1459 CleanupStack::PopAndDestroy(buf); |
|
1460 buf = modify->Reader()->GetRelatedSoundFileL(); |
|
1461 CleanupStack::PushL(buf); |
|
1462 if ( ( buf->Des().Ptr()[buf->Des().Length() - 1] != NULL ) && |
|
1463 ( buf->Des().Length() != 13 ) ) |
|
1464 { |
|
1465 User::Leave( KErrGeneral ); |
|
1466 } |
|
1467 CleanupStack::PopAndDestroy(buf); |
|
1468 buf = 0; |
|
1469 |
|
1470 buf = TUtils::CreateDummyBufL(14); |
|
1471 CleanupStack::PushL(buf); |
|
1472 *( CONST_CAST( TUint8*, buf->Des().Ptr()) + 13 ) = NULL; |
|
1473 TExifTagInfo tag3(KIdRelatedSoundFile, CExifTag::ETagAscii, 14); |
|
1474 TRAP( error, modify->SetTagL(EIfdExif, tag3, buf->Des()) ); |
|
1475 if ( error != KErrNotSupported ) |
|
1476 { |
|
1477 User::LeaveIfError( error ); |
|
1478 User::Leave( KErrGeneral ); |
|
1479 } |
|
1480 CleanupStack::PopAndDestroy(buf); |
|
1481 buf = 0; |
|
1482 |
|
1483 buf = TUtils::CreateDummyBufL(11); |
|
1484 CleanupStack::PushL(buf); |
|
1485 TExifTagInfo tag4(KIdRelatedSoundFile, CExifTag::ETagAscii, 11); |
|
1486 TRAP( error, modify->SetTagL(EIfdExif, tag4, buf->Des()) ); |
|
1487 if ( error != KErrNotSupported ) |
|
1488 { |
|
1489 User::LeaveIfError( error ); |
|
1490 User::Leave( KErrGeneral ); |
|
1491 } |
|
1492 CleanupStack::PopAndDestroy(buf); |
|
1493 buf = 0; |
|
1494 |
|
1495 CleanupStack::PopAndDestroy( modify ); |
|
1496 |
|
1497 } |
|
1498 |
|
1499 // Exif.Modify.MEM.017 |
|
1500 // Test the behavior of the previous test cases in OOM situations. |
|
1501 // Successfully operates or leaves with OOM error, without any memory leaks. |
|
1502 void CExifModifyTest2::ExifModify017L() |
|
1503 { |
|
1504 // OOM in EXIF.MODIFY.001- EXIF.MODIFY.016 |
|
1505 TInt error = KErrGeneral; |
|
1506 TInt i = 0; |
|
1507 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1508 for(i = 1; i < 500; i++) |
|
1509 #else |
|
1510 for(i = 1; i < 10; i++) |
|
1511 #endif |
|
1512 { |
|
1513 __UHEAP_MARK; |
|
1514 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1515 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1516 #else |
|
1517 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1518 #endif |
|
1519 TRAP(error, ExifModify001L()); |
|
1520 if(error) |
|
1521 { |
|
1522 if(error != KErrNoMemory) |
|
1523 { |
|
1524 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1525 User::Leave(KErrGeneral); |
|
1526 } |
|
1527 } |
|
1528 else |
|
1529 { |
|
1530 __UHEAP_MARKEND; |
|
1531 break; |
|
1532 } |
|
1533 __UHEAP_MARKEND; |
|
1534 } |
|
1535 |
|
1536 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1537 for(i = 1; i < 500; i++) |
|
1538 #else |
|
1539 for(i = 1; i < 10; i++) |
|
1540 #endif |
|
1541 { |
|
1542 __UHEAP_MARK; |
|
1543 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1544 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1545 #else |
|
1546 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1547 #endif |
|
1548 TRAP(error, ExifModify002L()); |
|
1549 if(error) |
|
1550 { |
|
1551 if(error != KErrNoMemory) |
|
1552 { |
|
1553 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1554 User::Leave(KErrGeneral); |
|
1555 } |
|
1556 } |
|
1557 else |
|
1558 { |
|
1559 __UHEAP_MARKEND; |
|
1560 break; |
|
1561 } |
|
1562 __UHEAP_MARKEND; |
|
1563 } |
|
1564 |
|
1565 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1566 for(i = 1; i < 500; i++) |
|
1567 #else |
|
1568 for(i = 1; i < 10; i++) |
|
1569 #endif |
|
1570 { |
|
1571 __UHEAP_MARK; |
|
1572 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1573 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1574 #else |
|
1575 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1576 #endif |
|
1577 TRAP(error, ExifModify003L()); |
|
1578 if(error) |
|
1579 { |
|
1580 if(error != KErrNoMemory) |
|
1581 { |
|
1582 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1583 User::Leave(KErrGeneral); |
|
1584 } |
|
1585 } |
|
1586 else |
|
1587 { |
|
1588 __UHEAP_MARKEND; |
|
1589 break; |
|
1590 } |
|
1591 __UHEAP_MARKEND; |
|
1592 } |
|
1593 |
|
1594 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1595 for(i = 1; i < 500; i++) |
|
1596 #else |
|
1597 for(i = 1; i < 10; i++) |
|
1598 #endif |
|
1599 { |
|
1600 __UHEAP_MARK; |
|
1601 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1602 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1603 #else |
|
1604 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1605 #endif |
|
1606 TRAP(error, ExifModify004L()); |
|
1607 if(error) |
|
1608 { |
|
1609 if(error != KErrNoMemory) |
|
1610 { |
|
1611 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1612 User::Leave(KErrGeneral); |
|
1613 } |
|
1614 } |
|
1615 else |
|
1616 { |
|
1617 __UHEAP_MARKEND; |
|
1618 break; |
|
1619 } |
|
1620 __UHEAP_MARKEND; |
|
1621 } |
|
1622 |
|
1623 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1624 for(i = 1; i < 500; i++) |
|
1625 #else |
|
1626 for(i = 1; i < 10; i++) |
|
1627 #endif |
|
1628 { |
|
1629 __UHEAP_MARK; |
|
1630 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1631 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1632 #else |
|
1633 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1634 #endif |
|
1635 TRAP(error, ExifModify005L()); |
|
1636 if(error) |
|
1637 { |
|
1638 if(error != KErrNoMemory) |
|
1639 { |
|
1640 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1641 User::Leave(KErrGeneral); |
|
1642 } |
|
1643 } |
|
1644 else |
|
1645 { |
|
1646 __UHEAP_MARKEND; |
|
1647 break; |
|
1648 } |
|
1649 __UHEAP_MARKEND; |
|
1650 } |
|
1651 |
|
1652 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1653 for(i = 1; i < 500; i++) |
|
1654 #else |
|
1655 for(i = 1; i < 10; i++) |
|
1656 #endif |
|
1657 { |
|
1658 __UHEAP_MARK; |
|
1659 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1660 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1661 #else |
|
1662 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1663 #endif |
|
1664 TRAP(error, ExifModify006L()); |
|
1665 if(error) |
|
1666 { |
|
1667 if(error != KErrNoMemory) |
|
1668 { |
|
1669 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1670 User::Leave(KErrGeneral); |
|
1671 } |
|
1672 } |
|
1673 else |
|
1674 { |
|
1675 __UHEAP_MARKEND; |
|
1676 break; |
|
1677 } |
|
1678 __UHEAP_MARKEND; |
|
1679 } |
|
1680 |
|
1681 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1682 for(i = 1; i < 500; i++) |
|
1683 #else |
|
1684 for(i = 1; i < 10; i++) |
|
1685 #endif |
|
1686 { |
|
1687 __UHEAP_MARK; |
|
1688 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1689 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1690 #else |
|
1691 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1692 #endif |
|
1693 TRAP(error, ExifModify007L()); |
|
1694 if(error) |
|
1695 { |
|
1696 if(error != KErrNoMemory) |
|
1697 { |
|
1698 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1699 User::Leave(KErrGeneral); |
|
1700 } |
|
1701 } |
|
1702 else |
|
1703 { |
|
1704 __UHEAP_MARKEND; |
|
1705 break; |
|
1706 } |
|
1707 __UHEAP_MARKEND; |
|
1708 } |
|
1709 |
|
1710 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1711 for(i = 1; i < 500; i++) |
|
1712 #else |
|
1713 for(i = 1; i < 10; i++) |
|
1714 #endif |
|
1715 { |
|
1716 __UHEAP_MARK; |
|
1717 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1718 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1719 #else |
|
1720 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1721 #endif |
|
1722 TRAP(error, ExifModify008L()); |
|
1723 if(error) |
|
1724 { |
|
1725 if(error != KErrNoMemory) |
|
1726 { |
|
1727 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1728 User::Leave(KErrGeneral); |
|
1729 } |
|
1730 } |
|
1731 else |
|
1732 { |
|
1733 __UHEAP_MARKEND; |
|
1734 break; |
|
1735 } |
|
1736 __UHEAP_MARKEND; |
|
1737 } |
|
1738 |
|
1739 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1740 for(i = 1; i < 500; i++) |
|
1741 #else |
|
1742 for(i = 1; i < 10; i++) |
|
1743 #endif |
|
1744 { |
|
1745 __UHEAP_MARK; |
|
1746 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1747 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1748 #else |
|
1749 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1750 #endif |
|
1751 TRAP(error, ExifModify009L()); |
|
1752 if(error) |
|
1753 { |
|
1754 if(error != KErrNoMemory) |
|
1755 { |
|
1756 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1757 User::Leave(KErrGeneral); |
|
1758 } |
|
1759 } |
|
1760 else |
|
1761 { |
|
1762 __UHEAP_MARKEND; |
|
1763 break; |
|
1764 } |
|
1765 __UHEAP_MARKEND; |
|
1766 } |
|
1767 |
|
1768 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1769 for(i = 1; i < 500; i++) |
|
1770 #else |
|
1771 for(i = 1; i < 10; i++) |
|
1772 #endif |
|
1773 { |
|
1774 __UHEAP_MARK; |
|
1775 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1776 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1777 #else |
|
1778 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1779 #endif |
|
1780 TRAP(error, ExifModify010L()); |
|
1781 if(error) |
|
1782 { |
|
1783 if(error != KErrNoMemory) |
|
1784 { |
|
1785 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1786 User::Leave(KErrGeneral); |
|
1787 } |
|
1788 } |
|
1789 else |
|
1790 { |
|
1791 __UHEAP_MARKEND; |
|
1792 break; |
|
1793 } |
|
1794 __UHEAP_MARKEND; |
|
1795 } |
|
1796 |
|
1797 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1798 for(i = 1; i < 500; i++) |
|
1799 #else |
|
1800 for(i = 1; i < 10; i++) |
|
1801 #endif |
|
1802 { |
|
1803 __UHEAP_MARK; |
|
1804 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1805 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1806 #else |
|
1807 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1808 #endif |
|
1809 TRAP(error, ExifModify011L()); |
|
1810 if(error) |
|
1811 { |
|
1812 if(error != KErrNoMemory) |
|
1813 { |
|
1814 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1815 User::Leave(KErrGeneral); |
|
1816 } |
|
1817 } |
|
1818 else |
|
1819 { |
|
1820 __UHEAP_MARKEND; |
|
1821 break; |
|
1822 } |
|
1823 __UHEAP_MARKEND; |
|
1824 } |
|
1825 |
|
1826 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1827 for(i = 1; i < 500; i++) |
|
1828 #else |
|
1829 for(i = 1; i < 10; i++) |
|
1830 #endif |
|
1831 { |
|
1832 __UHEAP_MARK; |
|
1833 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1834 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1835 #else |
|
1836 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1837 #endif |
|
1838 TRAP(error, ExifModify012L()); |
|
1839 if(error) |
|
1840 { |
|
1841 if(error != KErrNoMemory) |
|
1842 { |
|
1843 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1844 User::Leave(KErrGeneral); |
|
1845 } |
|
1846 } |
|
1847 else |
|
1848 { |
|
1849 __UHEAP_MARKEND; |
|
1850 break; |
|
1851 } |
|
1852 __UHEAP_MARKEND; |
|
1853 } |
|
1854 |
|
1855 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1856 for(i = 1; i < 500; i++) |
|
1857 #else |
|
1858 for(i = 1; i < 10; i++) |
|
1859 #endif |
|
1860 { |
|
1861 __UHEAP_MARK; |
|
1862 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1863 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1864 #else |
|
1865 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1866 #endif |
|
1867 TRAP(error, ExifModify013L()); |
|
1868 if(error) |
|
1869 { |
|
1870 if(error != KErrNoMemory) |
|
1871 { |
|
1872 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1873 User::Leave(KErrGeneral); |
|
1874 } |
|
1875 } |
|
1876 else |
|
1877 { |
|
1878 __UHEAP_MARKEND; |
|
1879 break; |
|
1880 } |
|
1881 __UHEAP_MARKEND; |
|
1882 } |
|
1883 |
|
1884 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1885 for(i = 1; i < 500; i++) |
|
1886 #else |
|
1887 for(i = 1; i < 10; i++) |
|
1888 #endif |
|
1889 { |
|
1890 __UHEAP_MARK; |
|
1891 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1892 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1893 #else |
|
1894 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1895 #endif |
|
1896 TRAP(error, ExifModify014L()); |
|
1897 if(error) |
|
1898 { |
|
1899 if(error != KErrNoMemory) |
|
1900 { |
|
1901 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1902 User::Leave(KErrGeneral); |
|
1903 } |
|
1904 } |
|
1905 else |
|
1906 { |
|
1907 __UHEAP_MARKEND; |
|
1908 break; |
|
1909 } |
|
1910 __UHEAP_MARKEND; |
|
1911 } |
|
1912 |
|
1913 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1914 for(i = 1; i < 500; i++) |
|
1915 #else |
|
1916 for(i = 1; i < 10; i++) |
|
1917 #endif |
|
1918 { |
|
1919 __UHEAP_MARK; |
|
1920 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1921 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1922 #else |
|
1923 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1924 #endif |
|
1925 TRAP(error, ExifModify015L()); |
|
1926 if(error) |
|
1927 { |
|
1928 if(error != KErrNoMemory) |
|
1929 { |
|
1930 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1931 User::Leave(KErrGeneral); |
|
1932 } |
|
1933 } |
|
1934 else |
|
1935 { |
|
1936 __UHEAP_MARKEND; |
|
1937 break; |
|
1938 } |
|
1939 __UHEAP_MARKEND; |
|
1940 } |
|
1941 |
|
1942 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1943 for(i = 1; i < 500; i++) |
|
1944 #else |
|
1945 for(i = 1; i < 10; i++) |
|
1946 #endif |
|
1947 { |
|
1948 __UHEAP_MARK; |
|
1949 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1950 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1951 #else |
|
1952 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1953 #endif |
|
1954 TRAP(error, ExifModify016L()); |
|
1955 if(error) |
|
1956 { |
|
1957 if(error != KErrNoMemory) |
|
1958 { |
|
1959 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1960 User::Leave(KErrGeneral); |
|
1961 } |
|
1962 } |
|
1963 else |
|
1964 { |
|
1965 __UHEAP_MARKEND; |
|
1966 break; |
|
1967 } |
|
1968 __UHEAP_MARKEND; |
|
1969 } |
|
1970 |
|
1971 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1972 for(i = 1; i < 500; i++) |
|
1973 #else |
|
1974 for(i = 1; i < 10; i++) |
|
1975 #endif |
|
1976 { |
|
1977 __UHEAP_MARK; |
|
1978 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
1979 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
1980 #else |
|
1981 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
1982 #endif |
|
1983 TRAP(error, ExifModify018L()); |
|
1984 if(error) |
|
1985 { |
|
1986 if(error != KErrNoMemory) |
|
1987 { |
|
1988 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
1989 User::Leave(KErrGeneral); |
|
1990 } |
|
1991 } |
|
1992 else |
|
1993 { |
|
1994 __UHEAP_MARKEND; |
|
1995 break; |
|
1996 } |
|
1997 __UHEAP_MARKEND; |
|
1998 } |
|
1999 |
|
2000 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
2001 for(i = 1; i < 500; i++) |
|
2002 #else |
|
2003 for(i = 1; i < 10; i++) |
|
2004 #endif |
|
2005 { |
|
2006 __UHEAP_MARK; |
|
2007 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) ) |
|
2008 __UHEAP_SETFAIL( RHeap::EFailNext, i ); |
|
2009 #else |
|
2010 __UHEAP_SETFAIL( RHeap::ERandom, i ); |
|
2011 #endif |
|
2012 TRAP(error, ExifModify019L()); |
|
2013 if(error) |
|
2014 { |
|
2015 if(error != KErrNoMemory) |
|
2016 { |
|
2017 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
2018 User::Leave(KErrGeneral); |
|
2019 } |
|
2020 } |
|
2021 else |
|
2022 { |
|
2023 __UHEAP_MARKEND; |
|
2024 break; |
|
2025 } |
|
2026 __UHEAP_MARKEND; |
|
2027 } |
|
2028 |
|
2029 __UHEAP_SETFAIL( RHeap::ENone, 0 ); |
|
2030 } |