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);