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.Create.101

    21 // Instantiate an Exif modifier with valid Jpeg image

    22 // Created Exif modifier instance in ECreate mode is returned.

    23 void CExifCreateTest::ExifCreate101L()

    24 	{

    25 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

    26 	CleanupStack::PushL(jpeg);

    27 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

    28 	if(!modify)

    29 		User::Leave(KErrGeneral);

    30 	delete modify;

    31 	CleanupStack::PopAndDestroy(jpeg);

    32 	}

    33 

    34 // Exif.Create.102

    35 // Try to instantiate an Exif modifier with invalid/ corrupted Jpeg image

    36 // Leaves with proper error code.

    37 void CExifCreateTest::ExifCreate102L()

    38 	{

    39 	// Various invalid/ corrupted Jpeg images

    40 

    41     // Not baseline Jpeg

    42 	HBufC8* jpeg = TUtils::ReadFileL( iFs, KInvalidJpeg1 );

    43 	CleanupStack::PushL( jpeg );

    44 	CExifModify* modify = 0;

    45     TRAPD( error, modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing) );

    46     if ( error ) // error detected

    47         {

    48         if ( ( error != KErrNotSupported ) || ( modify ) )

    49             {

    50             if ( modify )

    51                 {

    52                 delete modify;

    53                 }

    54             if ( error )

    55                 {

    56     		    User::Leave( error );

    57                 }

    58             User::Leave( KErrGeneral );

    59             }

    60         }

    61     delete modify;

    62     modify = 0;

    63 	CleanupStack::PopAndDestroy( jpeg );

    64 

    65     // No SOI

    66 	jpeg = TUtils::ReadFileL( iFs, KInvalidJpeg2 );

    67 	CleanupStack::PushL( jpeg );

    68 	TRAP( error, modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing) );

    69     if ( error ) // error detected

    70         {

    71         if ( ( error != KErrCorrupt ) || ( modify ) )

    72             {

    73             if ( modify )

    74                 {

    75                 delete modify;

    76                 }

    77             if ( error )

    78                 {

    79     		    User::Leave( error );

    80                 }

    81             User::Leave( KErrGeneral );

    82             }

    83         }

    84     delete modify;

    85     modify = 0;

    86 	CleanupStack::PopAndDestroy( jpeg );

    87 

    88     // No EOI

    89 	jpeg = TUtils::ReadFileL( iFs, KInvalidJpeg3 );

    90 	CleanupStack::PushL( jpeg );

    91 	TRAP( error, modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing) );

    92     if ( error ) // error detected

    93         {

    94         if ( ( error != KErrCorrupt ) || ( modify ) )

    95             {

    96             if ( modify )

    97                 {

    98                 delete modify;

    99                 }

   100             if ( error )

   101                 {

   102     		    User::Leave( error );

   103                 }

   104             User::Leave( KErrGeneral );

   105             }

   106         }

   107     delete modify;

   108     modify = 0;

   109 	CleanupStack::PopAndDestroy( jpeg );

   110 

   111 	jpeg = TUtils::CreateDummyBufL( 120000 );

   112     CleanupStack::PushL( jpeg );

   113 	HBufC8* jpeg2 = TUtils::ReadFileL( iFs, KValidJpeg );

   114     jpeg->Des().Copy( jpeg2->Ptr(), jpeg->Length() / 1000 );

   115     jpeg->Des().SetLength(120000);

   116     delete jpeg2;

   117     jpeg2 = 0;

   118 	TRAP( error, modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing) );

   119     if ( error ) // error detected

   120         {

   121         if ( ( error != KErrCorrupt ) || ( modify ) )

   122             {

   123             if ( modify )

   124                 {

   125                 delete modify;

   126                 }

   127             if ( error )

   128                 {

   129     		    User::Leave( error );

   130                 }

   131             User::Leave( KErrGeneral );

   132             }

   133         }

   134     delete modify;

   135     modify = 0;

   136 	CleanupStack::PopAndDestroy( jpeg );

   137     }

   138 

   139 // Exif.Create.103

   140 // Retrieve reader instance for the related Exif data.

   141 // Returns unmodifiable reader instance.

   142 void CExifCreateTest::ExifCreate103L()

   143 	{

   144 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   145 	CleanupStack::PushL(jpeg);

   146 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   147 	CleanupStack::PushL(modify);

   148 

   149 	const CExifRead* reader = modify->Reader();

   150 	if(!reader)

   151 		User::Leave(KErrGeneral);

   152 

   153 	CleanupStack::PopAndDestroy(modify);

   154 	CleanupStack::PopAndDestroy(jpeg);

   155 	}

   156 

   157 // Exif.Create.104

   158 // Insert/ Update a valid tag into the specified IFD in Exif data.

   159 // The given tag instance is inserted or updated.

   160 void CExifCreateTest::ExifCreate104L()

   161 	{

   162 //For each IFD.

   163 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   164 	CleanupStack::PushL(jpeg);

   165 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   166 	CleanupStack::PushL(modify);

   167 

   168 

   169 	HBufC8* buf = TUtils::CreateDummyBufL(16);

   170 	CleanupStack::PushL(buf);

   171 	TExifTagInfo tag(KIdImageDescription, CExifTag::ETagAscii, 16);

   172 	modify->SetTagL(EIfd0, tag, buf->Des());

   173 	CleanupStack::PopAndDestroy(buf);

   174 

   175 	buf = TUtils::CreateDummyBufL(20);

   176 	CleanupStack::PushL(buf);

   177 	tag.iId = KIdUserComment;

   178 	tag.iDataType = CExifTag::ETagUndefined;

   179 	tag.iDataCount = 20; 

   180 	modify->SetTagL(EIfdExif, tag, buf->Des());

   181 	CleanupStack::PopAndDestroy(buf);

   182 

   183 	buf = TUtils::CreateDummyBufL(2);

   184 	CleanupStack::PushL(buf);

   185 	*(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 0;

   186 	tag.iId = KIdExposureProgram;

   187 	tag.iDataType = CExifTag::ETagShort;

   188 	tag.iDataCount = 1;

   189 	modify->SetTagL(EIfdExif, tag, buf->Des());

   190 	CleanupStack::PopAndDestroy(buf);

   191 

   192 	buf = TUtils::CreateDummyBufL(1);

   193 	CleanupStack::PushL(buf);

   194 	tag.iId = 3;

   195 	tag.iDataType = CExifTag::ETagAscii;

   196 	tag.iDataCount = 1;

   197 	modify->SetTagL(EIfdGps, tag, buf->Des());

   198 	CleanupStack::PopAndDestroy(buf);

   199 

   200 	buf = TUtils::CreateDummyBufL(3);

   201 	CleanupStack::PushL(buf);

   202 	tag.iId = 1;

   203 	tag.iDataType = CExifTag::ETagAscii;

   204 	tag.iDataCount = 3;

   205 	modify->SetTagL(EIfdIntOp, tag, buf->Des());

   206 	CleanupStack::PopAndDestroy(buf);

   207 

   208 	buf = TUtils::CreateDummyBufL(2);

   209 	CleanupStack::PushL(buf);

   210 	*(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 2;

   211 	tag.iId = KIdResolutionUnit;

   212 	tag.iDataType = CExifTag::ETagShort;

   213 	tag.iDataCount = 1; 

   214 	modify->SetTagL(EIfd1, tag, buf->Des());

   215 	CleanupStack::PopAndDestroy(buf);

   216 

   217 	CleanupStack::PopAndDestroy(modify);

   218 	CleanupStack::PopAndDestroy(jpeg);	

   219 	}

   220 

   221 // Exif.Create.105

   222 // Try to insert/ update an invalid tag into the specified IFD in Exif data.

   223 // Leaves with proper error code.

   224 void CExifCreateTest::ExifCreate105L()

   225 	{

   226 //* Tag is not allowed to be inserted into the specified IFD,

   227 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   228 	CleanupStack::PushL(jpeg);

   229 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   230 	CleanupStack::PushL(modify);

   231 

   232 

   233 	HBufC8* buf = TUtils::CreateDummyBufL(16);

   234 	CleanupStack::PushL(buf);

   235 	TExifTagInfo tag(KIdImageDescription, CExifTag::ETagAscii, 16);

   236 	TRAPD(error, modify->SetTagL(EIfdExif, tag, buf->Des()));

   237 	if(error != KErrNotSupported)

   238 	{

   239 		if(error)

   240 			User::Leave(error);

   241 		User::Leave(KErrGeneral);

   242 	}

   243 	CleanupStack::PopAndDestroy(buf);

   244 

   245 	buf = TUtils::CreateDummyBufL(20);

   246 	CleanupStack::PushL(buf);

   247 	tag.iId = KIdUserComment;

   248 	tag.iDataType = CExifTag::ETagUndefined;

   249 	tag.iDataCount = 20; 

   250 	TRAP(error, modify->SetTagL(EIfd1, tag, buf->Des()));

   251 	if(error != KErrNotSupported)

   252 	{

   253 		if(error)

   254 			User::Leave(error);

   255 		User::Leave(KErrGeneral);

   256 	}

   257 	CleanupStack::PopAndDestroy(buf);

   258 

   259 	buf = TUtils::CreateDummyBufL(2);

   260 	CleanupStack::PushL(buf);

   261 	*(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 0;

   262 	tag.iId = KIdExposureProgram;

   263 	tag.iDataType = CExifTag::ETagShort;

   264 	tag.iDataCount = 1; 

   265 	TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des()));

   266 	if(error != KErrNotSupported)

   267 	{

   268 		if(error)

   269 			User::Leave(error);

   270 		User::Leave(KErrGeneral);

   271 	}

   272 	CleanupStack::PopAndDestroy(buf);

   273 

   274 	buf = TUtils::CreateDummyBufL(2);

   275 	CleanupStack::PushL(buf);

   276 	tag.iId = 3;

   277 	tag.iDataType = CExifTag::ETagAscii;

   278 	tag.iDataCount = 2; 

   279 	TRAP(error, modify->SetTagL(EIfdIntOp, tag, buf->Des()));

   280 	if(error != KErrNotSupported)

   281 	{

   282 		if(error)

   283 			User::Leave(error);

   284 		User::Leave(KErrGeneral);

   285 	}

   286 

   287 	CleanupStack::PopAndDestroy(buf);

   288 

   289 	buf = TUtils::CreateDummyBufL(3);

   290 	CleanupStack::PushL(buf);

   291 	tag.iId = 1;

   292 	tag.iDataType = CExifTag::ETagAscii;

   293 	tag.iDataCount = 3; 

   294 	TRAP(error, modify->SetTagL(EIfdExif, tag, buf->Des()));

   295 	if(error != KErrNotSupported)

   296 	{

   297 		if(error)

   298 			User::Leave(error);

   299 		User::Leave(KErrGeneral);

   300 	}

   301 	CleanupStack::PopAndDestroy(buf);

   302 

   303 	buf = TUtils::CreateDummyBufL(2);

   304 	CleanupStack::PushL(buf);

   305 	*(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 2;

   306 	tag.iId = KIdResolutionUnit;

   307 	tag.iDataType = CExifTag::ETagShort;

   308 	tag.iDataCount = 1; 

   309 	TRAP(error, modify->SetTagL(EIfdGps, tag, buf->Des()));

   310 	if(error != KErrNotSupported)

   311 	{

   312 		if(error)

   313 			User::Leave(error);

   314 		User::Leave(KErrGeneral);

   315 	}

   316 	CleanupStack::PopAndDestroy(buf);

   317 

   318     //* The Exif data size exceeds 64K" 

   319 

   320 	buf = TUtils::CreateDummyBufL(66000);

   321 	CleanupStack::PushL(buf);

   322 	tag.iId = 8;

   323 	tag.iDataType = CExifTag::ETagAscii;

   324 	tag.iDataCount = 66000; 

   325 	TRAP(error, modify->SetTagL(EIfdGps, tag, buf->Des()));

   326 	if(error != KErrOverflow)

   327 	{

   328 		if(error)

   329 			User::Leave(error);

   330 		User::Leave(KErrGeneral);

   331 	}

   332 	CleanupStack::PopAndDestroy(buf);

   333 

   334 	// Tag ID is invalid,	

   335 	buf = TUtils::CreateDummyBufL(19);

   336 	CleanupStack::PushL(buf);

   337 	tag.iId = 200;

   338 	tag.iDataType = CExifTag::ETagAscii;

   339 	tag.iDataCount = 19; 

   340 	TRAP(error, modify->SetTagL(EIfdGps, tag, buf->Des()));

   341 	if(error != KErrNotSupported)

   342 	{

   343 		if(error)

   344 			User::Leave(error);

   345 		User::Leave(KErrGeneral);

   346 	}

   347 	CleanupStack::PopAndDestroy(buf);

   348 

   349 	//Tag ID doesn't match with the data type, (Full validity)

   350 	//* Not supported yet!!!

   351 	buf = TUtils::CreateDummyBufL(20);

   352 	CleanupStack::PushL(buf);

   353 	tag.iId = KIdImageDescription;

   354 	tag.iDataType = CExifTag::ETagByte;

   355 	tag.iDataCount = 20; 

   356 	TRAP(error, modify->SetTagL(EIfd0, 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 

   366 	//Data count doesn't match with the given tag data size

   367 	buf = TUtils::CreateDummyBufL(19);

   368 	CleanupStack::PushL(buf);

   369 	tag.iId = KIdImageDescription;

   370 	tag.iDataType = CExifTag::ETagAscii;

   371 	tag.iDataCount = 24; 

   372 	TRAP(error, modify->SetTagL(EIfd0, tag, buf->Des()));

   373 	if(error != KErrArgument)

   374 	{

   375 		if(error)

   376 			User::Leave(error);

   377 		User::Leave(KErrGeneral);

   378 	}

   379 	CleanupStack::PopAndDestroy(buf);

   380 

   381 	//Tag data value is not valid (Full validity) 

   382     // !!! DROPPED !!!

   383 	/* Not supported yet!!!

   384 	buf = TUtils::CreateDummyBufL(2);

   385 	CleanupStack::PushL(buf);

   386 	tag.iId = KIdImageDescription;

   387 	tag.iDataType = CExifTag::ETagShort;

   388 	tag.iDataCount = 2; 

   389 	*(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 200;

   390 	TRAP(error, modify->SetTagL(EIfdExif, tag, buf->Des()));

   391 	if(error != KErrArgument)

   392 	{

   393 		if(error)

   394 			User::Leave(error);

   395 		User::Leave(KErrGeneral);

   396 	}

   397 	CleanupStack::PopAndDestroy(buf);

   398     */

   399 

   400     // Data length = 0

   401     buf = TUtils::CreateDummyBufL(2);

   402     buf->Des().SetLength(0);

   403 	CleanupStack::PushL(buf);

   404 	tag.iId = KIdImageDescription;

   405 	tag.iDataType = CExifTag::ETagShort;

   406 	tag.iDataCount = 2; 

   407 	*(reinterpret_cast<TUint16*>(const_cast<TUint8*>(buf->Ptr()))) = 200;

   408 	TRAP(error, modify->SetTagL(EIfdExif, tag, buf->Des()));

   409 	if(error != KErrArgument)

   410 	{

   411 		if(error)

   412 			User::Leave(error);

   413 		User::Leave(KErrGeneral);

   414 	}

   415 	CleanupStack::PopAndDestroy(buf);

   416 

   417 	CleanupStack::PopAndDestroy(modify);

   418 	CleanupStack::PopAndDestroy(jpeg);	

   419 	}

   420 

   421 // Exif.Create.106

   422 // Insert/ Update compressed Exif thumbnail image into the the Exif data.

   423 // Inserts/ Updates the Exif thumbnail image

   424 void CExifCreateTest::ExifCreate106L()

   425 	{

   426 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   427 	CleanupStack::PushL(jpeg);

   428 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   429 	CleanupStack::PushL(modify);

   430 

   431 	HBufC8* thumbnail = TUtils::ReadFileL(iFs, KValidThumbnail);

   432 	CleanupStack::PushL(thumbnail);

   433 	modify->SetThumbnailL(thumbnail->Des());

   434 	CleanupStack::PopAndDestroy(thumbnail);

   435 

   436 	CleanupStack::PopAndDestroy(modify);

   437 	CleanupStack::PopAndDestroy(jpeg);	

   438 	}

   439 

   440 // Exif.Create.107

   441 // Try to Insert/ Update compressed Exif thumbnail image with in invalid cases.

   442 // Leaves with proper error code.

   443 void CExifCreateTest::ExifCreate107L()

   444 	{

   445 	TInt error = 0;

   446     HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   447 	CleanupStack::PushL(jpeg);

   448     CExifModify* modify = 0;

   449     //"* Given thumbnail data is not valid compressed Exif thumbnail image, !! Not supported yet !!

   450     modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   451 	CleanupStack::PushL(modify);

   452 

   453     HBufC8* buf = TUtils::CreateDummyBufL(8000);

   454 	CleanupStack::PushL(buf);

   455 	TRAP( error, modify->SetThumbnailL(buf->Des()) );

   456     if ( error != KErrCorrupt )

   457         {

   458         if ( error )

   459             {

   460             User::Leave( error );

   461             }

   462         User::Leave( KErrGeneral );

   463         }

   464     CleanupStack::PopAndDestroy( buf );

   465     

   466 

   467 //* The Exif data size exceeds 64K"

   468 	TExifTagInfo tag(KIdImageDescription, CExifTag::ETagAscii, 60000);

   469     buf = TUtils::CreateDummyBufL(60000);

   470 	CleanupStack::PushL(buf);

   471 	modify->SetTagL(EIfd0, tag, buf->Des());

   472 	CleanupStack::PopAndDestroy(buf);

   473 

   474 	HBufC8* thumbnail = TUtils::ReadFileL(iFs, KValidThumbnail);

   475 	CleanupStack::PushL(thumbnail);

   476 	TRAP( error, modify->SetThumbnailL(thumbnail->Des()) );

   477     if ( error != KErrOverflow )

   478         {

   479         if ( error )

   480             {

   481             User::Leave( error );

   482             }

   483         User::Leave( KErrGeneral );

   484         }

   485 	CleanupStack::PopAndDestroy(thumbnail);

   486 

   487 	CleanupStack::PopAndDestroy(modify);

   488 	CleanupStack::PopAndDestroy(jpeg);	

   489 	}

   490 

   491 // Exif.Create.108

   492 // Write the final Exif image to a buffer.

   493 // Writes the whole Exif image in a buffer, and returns the buffer.

   494 void CExifCreateTest::ExifCreate108L()

   495 	{

   496 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   497 	CleanupStack::PushL(jpeg);

   498 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   499 	CleanupStack::PushL(modify);

   500 

   501 	// Insert Tags

   502 	HBufC8* buf = 0;

   503 	TUint16 tmp1 = 0;

   504 	TUint32 tmp3 = 0;

   505 	TUint32 tmp4 = 0;

   506 

   507 	tmp3 = 72;

   508 	tmp4 = 1;

   509 	modify->SetXResolutionL(tmp3, tmp4);

   510 	modify->SetYResolutionL(tmp3, tmp4);

   511 	tmp1 = 2;

   512 	modify->SetResolutionUnitL(tmp1);

   513 	tmp1 = 1;

   514 	modify->SetYCbCrPositioningL(tmp1);

   515 

   516 	tmp3 = 0x1230;

   517 	modify->SetComponentsConfigurationL(1, 2, 3, 0);

   518 	tmp1 = 1;

   519 	modify->SetColorSpaceL(tmp1);

   520 	tmp3 = 1024;

   521 	modify->SetPixelXDimensionL(tmp3);

   522 	tmp3 = 768;

   523 	modify->SetPixelYDimensionL(tmp3);

   524 

   525 

   526 	buf = TUtils::CreateDummyBufL(5);

   527 	CleanupStack::PushL(buf);

   528 	modify->SetImageDescriptionL(buf->Des());

   529 	CleanupStack::PopAndDestroy(buf);

   530 	buf = 0;

   531 

   532 	

   533 	buf = TUtils::CreateDummyBufL(768*2);

   534 	CleanupStack::PushL(buf);

   535 	modify->SetTransferFunctionL(buf->Des());

   536 	CleanupStack::PopAndDestroy(buf);

   537 	buf = 0;

   538 	

   539 	modify->SetExposureModeL(0);

   540 	modify->SetWhiteBalanceL(0);

   541 	modify->SetSceneCaptureTypeL(0);

   542 	modify->SetExposureProgramL(0);

   543 	

   544 	modify->SetLightSourceL(0);

   545 

   546 	buf = TUtils::CreateDummyBufL(16);

   547 	CleanupStack::PushL(buf);

   548 	modify->SetMakerNoteL(buf->Des());

   549 	CleanupStack::PopAndDestroy(buf);

   550 	buf = 0;

   551 

   552 	HBufC8* buffer = modify->WriteDataL(jpeg->Des());

   553 	if(!buffer)

   554         User::Leave(KErrGeneral);

   555 	delete buffer;

   556 	buffer = 0;

   557 

   558     TPtrC8 tmpDes;

   559     buffer = modify->WriteDataL( tmpDes );

   560 	if(!buffer)

   561         User::Leave(KErrGeneral);

   562 	delete buffer;

   563 

   564 	CleanupStack::PopAndDestroy(modify);

   565 	CleanupStack::PopAndDestroy(jpeg);	

   566 	}

   567 

   568 

   569 // Exif.Create.109

   570 // Try to write the final Exif image to a buffer for invalid cases or incorrect original data buffer

   571 // Leaves with proper error code.

   572 void CExifCreateTest::ExifCreate109L()

   573 	{

   574 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   575 	CleanupStack::PushL(jpeg);

   576 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   577 	CleanupStack::PushL(modify);

   578 

   579 //"* Given buffer content is not the same with the original buffer content

   580     TInt error = 0;

   581 	HBufC8* buf = 0;

   582     HBufC8* buffer = 0;

   583     

   584     buf = TUtils::CreateDummyBufL( jpeg->Length() );

   585     CleanupStack::PushL( buf );

   586     TRAP( error, buffer = modify->WriteDataL( *buf ) );

   587     

   588     if ( ( error != KErrArgument ) || ( buffer ) )

   589         {

   590         if ( buffer )

   591             delete buffer;

   592         if ( error )

   593             {

   594             User::Leave( error );

   595             }

   596         User::Leave( KErrGeneral );

   597         }

   598     CleanupStack::PopAndDestroy( buf );

   599 

   600 //* The Exif data doesn't contain all mandatory tags"

   601 

   602 	// Insert Tags

   603 	TUint16 tmp1 = 0;

   604 	TUint32 tmp3 = 0;

   605 	TUint32 tmp4 = 0;

   606 

   607 	tmp3 = 72;

   608 	tmp4 = 1;

   609 	modify->SetXResolutionL(tmp3, tmp4);

   610 	tmp1 = 2;

   611 	modify->SetResolutionUnitL(tmp1);

   612 

   613 	tmp3 = 0x1230;

   614 	modify->SetComponentsConfigurationL(1, 2, 3, 0);

   615 	tmp1 = 1;

   616 	modify->SetColorSpaceL(tmp1);

   617 	tmp3 = 768;

   618 	modify->SetPixelYDimensionL(tmp3);

   619 

   620 

   621 	buf = TUtils::CreateDummyBufL(5);

   622 	CleanupStack::PushL(buf);

   623 	modify->SetImageDescriptionL(buf->Des());

   624 	CleanupStack::PopAndDestroy(buf);

   625 	buf = 0;

   626 

   627 	

   628 	buf = TUtils::CreateDummyBufL(768*2);

   629 	CleanupStack::PushL(buf);

   630 	modify->SetTransferFunctionL(buf->Des());

   631 	CleanupStack::PopAndDestroy(buf);

   632 	buf = 0;

   633 	

   634 	modify->SetExposureModeL(0);

   635 	modify->SetWhiteBalanceL(0);

   636 	modify->SetSceneCaptureTypeL(0);

   637 	modify->SetExposureProgramL(0);

   638 	

   639 	modify->SetLightSourceL(0);

   640 

   641 	buf = TUtils::CreateDummyBufL(16);

   642 	CleanupStack::PushL(buf);

   643 	modify->SetMakerNoteL(buf->Des());

   644 	CleanupStack::PopAndDestroy(buf);

   645 	buf = 0;

   646 

   647 	buffer = 0;

   648 	TRAP(error, buffer = modify->WriteDataL(jpeg->Des()));

   649 	if(buffer)

   650 		{

   651 		delete buffer;

   652 		User::Leave(KErrGeneral);

   653 		}

   654 	if(error != KErrNotReady)

   655 	    {

   656 		if(error)

   657 			User::Leave(error);

   658 		User::Leave(KErrGeneral);

   659 	    }

   660 

   661 	CleanupStack::PopAndDestroy(modify);

   662 	CleanupStack::PopAndDestroy(jpeg);	

   663 	}

   664 

   665 // Exif.Create.110

   666 // Insert/Update specific data using Set functions.

   667 // Inserts/ Updates the tag data

   668 void CExifCreateTest::ExifCreate110L()

   669 	{

   670 //For each Set function.

   671 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   672 	CleanupStack::PushL(jpeg);

   673 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   674 	CleanupStack::PushL(modify);

   675 

   676 	// For some Set functions.

   677 	// Insert Tags

   678 	HBufC8* buf = 0;

   679     TUint16 tmp1 = 0;

   680 	TUint32 tmp3 = 0;

   681 	TUint32 tmp4 = 0;

   682     TInt32 tmp5 = 0;

   683     TInt32 tmp6 = 0;

   684 

   685 	buf = TUtils::CreateDummyBufL(10);

   686 	CleanupStack::PushL(buf);

   687     modify->SetUserCommentL(buf->Des());

   688 	CleanupStack::PopAndDestroy(buf);

   689 	buf = 0;

   690 

   691 	buf = TUtils::CreateDummyBufL(4);

   692 	CleanupStack::PushL(buf);

   693     modify->SetModelL(buf->Des());

   694 	CleanupStack::PopAndDestroy(buf);

   695 	buf = 0;

   696 

   697     tmp1 = 0;

   698     modify->SetMeteringModeL(tmp1);

   699 

   700     tmp5 = 1;

   701     tmp6 = 1;

   702     modify->SetExposureBiasValueL(tmp5, tmp6);

   703 

   704 	buf = TUtils::CreateDummyBufL(19);

   705 	CleanupStack::PushL(buf);

   706     buf->Des().Copy(_L("2004:01:19 11:00:00"));

   707     modify->SetDateTimeOriginalL(buf->Des());

   708     modify->SetDateTimeDigitizedL(buf->Des());

   709 	CleanupStack::PopAndDestroy(buf);

   710 	buf = 0;

   711 

   712     tmp5 = 1;

   713     tmp6 = 1;

   714     modify->SetApertureValueL(tmp5, tmp6);

   715     

   716 	buf = TUtils::CreateDummyBufL(12);

   717 	CleanupStack::PushL(buf);

   718 	modify->SetImageDescriptionL(buf->Des());

   719 	CleanupStack::PopAndDestroy(buf);

   720 

   721 	buf = TUtils::CreateDummyBufL(12);

   722 	CleanupStack::PushL(buf);

   723 	modify->SetMakeL(buf->Des());

   724 	CleanupStack::PopAndDestroy(buf);

   725 

   726 	modify->SetOrientationL(1);

   727 	modify->SetExposureModeL(0);

   728 	modify->SetWhiteBalanceL(0);

   729 	modify->SetSceneCaptureTypeL(0);

   730 	modify->SetExposureProgramL(0);

   731 

   732 	tmp3 = 72;

   733 	tmp4 = 1;

   734 	modify->SetXResolutionL(tmp3, tmp4);

   735 	modify->SetThumbnailYResolutionL(tmp3, tmp4);

   736 	modify->SetFileSourceL(1); 

   737 	modify->SetSharpnessL(0); 

   738 

   739 	CleanupStack::PopAndDestroy(modify);

   740 	CleanupStack::PopAndDestroy(jpeg);	

   741 	}

   742 

   743 // Exif.Create.111

   744 // Try to Insert/Update specific data using Set functions in invalid cases.

   745 // Leaves with or returns proper error code.

   746 void CExifCreateTest::ExifCreate111L()

   747 	{

   748 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   749 	CleanupStack::PushL(jpeg);

   750 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   751 	CleanupStack::PushL(modify);

   752 //"* Data size is invalid 

   753 	HBufC8* buf = 0;

   754 	buf = TUtils::CreateDummyBufL(700);

   755 	CleanupStack::PushL(buf);

   756 	TRAPD(error, modify->SetTransferFunctionL(buf->Des()));

   757 	if(error != KErrNotSupported)

   758 	{

   759 		if(error)

   760 			User::Leave(error);

   761 		User::Leave(KErrGeneral);

   762 	}

   763 	CleanupStack::PopAndDestroy(buf);

   764 

   765 //* Data value is invalid" (Full validity) 

   766     // !!! DROPPED !!!

   767 

   768 	CleanupStack::PopAndDestroy(modify);

   769 	CleanupStack::PopAndDestroy(jpeg);	

   770 	}

   771 

   772 // Exif.Create.112

   773 // Test the behavior of the previous test cases after the Exif image is written into a buffer (WriteDataL) called.

   774 // Leaves with or returns proper error code.

   775 // CHANGED:

   776 // This feature is changed. Multiple usage is allowed any more. Test using the modifier after WriteDataL function.

   777 void CExifCreateTest::ExifCreate112L()

   778 	{

   779 	HBufC8* jpeg = TUtils::ReadFileL(iFs, KValidJpeg);

   780 	CleanupStack::PushL(jpeg);

   781 	CExifModify* modify = CExifModify::NewL(*jpeg, CExifModify::ECreate, CExifModify::ENoJpegParsing);

   782 	CleanupStack::PushL(modify);

   783 

   784 	// Insert Tags

   785 	TUint16 tmp1 = 0;

   786 	TUint32 tmp3 = 0;

   787 	TUint32 tmp4 = 0;

   788 

   789     modify->SetYCbCrPositioningL(2);

   790 	modify->SetComponentsConfigurationL(1, 2, 3, 0);

   791 	tmp1 = 1;

   792 	modify->SetColorSpaceL(tmp1);

   793 	tmp3 = 480;

   794 	modify->SetPixelYDimensionL(tmp3);

   795 

   796 	tmp3 = 72;

   797 	tmp4 = 1;

   798 	modify->SetXResolutionL(tmp3, tmp4);

   799     modify->SetYResolutionL(tmp3, tmp4);

   800 	tmp1 = 2;

   801 	modify->SetResolutionUnitL(tmp1);

   802 

   803     HBufC8* buffer = NULL;

   804     TRAPD( error, buffer = modify->WriteDataL( jpeg->Des() ) );

   805     if( (error != KErrNotReady) || (buffer) )

   806         {

   807         if( buffer )

   808             delete buffer;

   809         buffer = 0;

   810         if( error )

   811             {

   812             User::Leave( error);

   813             }

   814         User::Leave( KErrGeneral );

   815         }

   816 

   817     TPtrC8 tmpDes;

   818     TRAP( error, buffer = modify->WriteDataL( tmpDes ) );

   819     if( (error != KErrNotReady) || (buffer) )

   820         {

   821         if( buffer )

   822             delete buffer;

   823         buffer = 0;

   824         if( error )

   825             {

   826             User::Leave( error);

   827             }

   828         User::Leave( KErrGeneral );

   829         }

   830 

   831     modify->SetPixelXDimensionL(640);

   832     

   833     TRAP( error, buffer = modify->WriteDataL( tmpDes ) );

   834     if( (error != KErrNone) || (!buffer) )

   835         {

   836         if( buffer )

   837             delete buffer;

   838         buffer = 0;

   839         if( error )

   840             {

   841             User::Leave( error);

   842             }

   843         User::Leave( KErrGeneral );

   844         }

   845     delete buffer;

   846     buffer = 0;

   847 

   848     TRAP( error, buffer = modify->WriteDataL( jpeg->Des() ) );

   849     if( (error != KErrNone) || (!buffer) )

   850         {

   851         if( buffer )

   852             delete buffer;

   853         buffer = 0;

   854         if( error )

   855             {

   856             User::Leave( error);

   857             }

   858         User::Leave( KErrGeneral );

   859         }

   860 

   861     CleanupStack::PushL(buffer);

   862     RFile file;

   863 	TBuf<255> fileName;

   864     fileName.Copy(KRootOut);

   865 	fileName.Append(_L("out\\"));

   866 	fileName.Append(_L("Create112_01.jpg"));

   867 	if(file.Open(iFs, fileName, EFileWrite) != KErrNone)

   868         {

   869 		if(file.Create(iFs, fileName, EFileWrite) != KErrNone)

   870             {

   871             fileName.Copy(KRootC);

   872 	        fileName.Append(_L("out\\"));

   873 	        fileName.Append(_L("Create112_01.jpg"));

   874 	        if(file.Open(iFs, fileName, EFileWrite) != KErrNone)

   875                 {

   876 		        if(file.Create(iFs, fileName, EFileWrite) != KErrNone)

   877                     {

   878                     fileName.Copy(KRootData);

   879 	                fileName.Append(_L("out\\"));

   880 	                fileName.Append(_L("Create112_01.jpg"));

   881 	                if(file.Open(iFs, fileName, EFileWrite) != KErrNone)

   882                         {

   883                         User::LeaveIfError(file.Create(iFs, fileName, EFileWrite));    

   884                         }

   885                     }

   886                 }

   887             }

   888         }

   889  

   890     file.Write(buffer->Des());

   891     file.Close();

   892     CleanupStack::PopAndDestroy(buffer);

   893     buffer = 0;

   894 

   895     TRAP( error, buffer = modify->WriteDataL( tmpDes ) );

   896     if( (error != KErrNone) || (!buffer) )

   897         {

   898         if( buffer )

   899             delete buffer;

   900         buffer = 0;

   901         if( error )

   902             {

   903             User::Leave( error);

   904             }

   905         User::Leave( KErrGeneral );

   906         }

   907     delete buffer;

   908     buffer = 0;

   909 

   910 

   911     TRAP( error, buffer = modify->WriteDataL( jpeg->Des() ) );

   912     if( (error != KErrNone) || (!buffer) )

   913         {

   914         if( buffer )

   915             delete buffer;

   916         buffer = 0;

   917         if( error )

   918             {

   919             User::Leave( error);

   920             }

   921         User::Leave( KErrGeneral );

   922         }

   923 

   924     CleanupStack::PushL(buffer);

   925     fileName.Copy(KRootOut);

   926 	fileName.Append(_L("out\\"));

   927 	fileName.Append(_L("Create112_02.jpg"));

   928 	if(file.Open(iFs, fileName, EFileWrite) != KErrNone)

   929         {

   930 		if(file.Create(iFs, fileName, EFileWrite) != KErrNone)

   931             {

   932             fileName.Copy(KRootC);

   933 	        fileName.Append(_L("out\\"));

   934 	        fileName.Append(_L("Create112_02.jpg"));

   935 	        if(file.Open(iFs, fileName, EFileWrite) != KErrNone)

   936                 {

   937 		        if(file.Create(iFs, fileName, EFileWrite) != KErrNone)

   938                     {

   939                     fileName.Copy(KRootData);

   940 	                fileName.Append(_L("out\\"));

   941 	                fileName.Append(_L("Create112_02.jpg"));

   942 	                if(file.Open(iFs, fileName, EFileWrite) != KErrNone)

   943                         {

   944                         User::LeaveIfError(file.Create(iFs, fileName, EFileWrite));    

   945                         }

   946                     }

   947                 }

   948             }

   949         }

   950  

   951     file.Write(buffer->Des());

   952     file.Close();

   953     CleanupStack::PopAndDestroy(buffer);

   954     buffer = 0;

   955 

   956     modify->DeleteTag(EIfdExif, KIdPixelXDimension);

   957 

   958     TRAP( error, buffer = modify->WriteDataL( jpeg->Des() ) );

   959     if( (error != KErrNotReady) || (buffer) )

   960         {

   961         if( buffer )

   962             delete buffer;

   963         buffer = 0;

   964         if( error )

   965             {

   966             User::Leave( error);

   967             }

   968         User::Leave( KErrGeneral );

   969         }    

   970 

   971     TRAP( error, buffer = modify->WriteDataL( tmpDes ) );

   972     if( (error != KErrNotReady) || (buffer) )

   973         {

   974         if( buffer )

   975             delete buffer;

   976         buffer = 0;

   977         if( error )

   978             {

   979             User::Leave( error);

   980             }

   981         User::Leave( KErrGeneral );

   982         }    

   983 

   984 	CleanupStack::PopAndDestroy(modify);

   985 	CleanupStack::PopAndDestroy(jpeg);	

   986 	}

   987 

   988 // Exif.Create.MEM.013

   989 // Test the behavior of the previous test cases in OOM situations.

   990 // Successfully operates or leaves with OOM error, without any memory leaks.

   991 void CExifCreateTest::ExifCreate113L()

   992 	{

   993 //OOM in EXIF.Create.101- EXIF.Create.112

   994 	TInt error = KErrGeneral;

   995 	TInt i = 0;

   996 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

   997 	for(i = 1; i < 500; i++)

   998 #else

   999     for(i = 1; i < 10; i++)

  1000 #endif

  1001 		{

  1002 		__UHEAP_MARK;

  1003 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

  1004 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

  1005 #else

  1006         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1007 #endif

  1008 		TRAP(error, ExifCreate101L());

  1009 		if(error)

  1010 			{

  1011 			if(error != KErrNoMemory)

  1012 				{

  1013 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1014 				User::Leave(KErrGeneral);

  1015 				}

  1016 			}

  1017 		else

  1018 			{

  1019 			__UHEAP_MARKEND;

  1020 			break;

  1021 			}

  1022 		__UHEAP_MARKEND;

  1023 		}

  1024 

  1025 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

  1026 	for(i = 1; i < 500; i++)

  1027 #else

  1028     for(i = 1; i < 10; i++)

  1029 #endif

  1030 		{

  1031 		__UHEAP_MARK;

  1032 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

  1033 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

  1034 #else

  1035         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1036 #endif

  1037 		TRAP(error, ExifCreate102L());

  1038 		if(error)

  1039 			{

  1040 			if(error != KErrNoMemory)

  1041 				{

  1042 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1043 				User::Leave(KErrGeneral);

  1044 				}

  1045 			}

  1046 		else

  1047 			{

  1048 			__UHEAP_MARKEND;

  1049 			break;

  1050 			}

  1051 		__UHEAP_MARKEND;

  1052 		}

  1053 

  1054 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

  1055 	for(i = 1; i < 500; i++)

  1056 #else

  1057     for(i = 1; i < 10; i++)

  1058 #endif

  1059 		{

  1060 		__UHEAP_MARK;

  1061 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

  1062 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

  1063 #else

  1064         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1065 #endif

  1066 		TRAP(error, ExifCreate103L());

  1067 		if(error)

  1068 			{

  1069 			if(error != KErrNoMemory)

  1070 				{

  1071 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1072 				User::Leave(KErrGeneral);

  1073 				}

  1074 			}

  1075 		else

  1076 			{

  1077 			__UHEAP_MARKEND;

  1078 			break;

  1079 			}

  1080 		__UHEAP_MARKEND;

  1081 		}

  1082 

  1083 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

  1084 	for(i = 1; i < 500; i++)

  1085 #else

  1086     for(i = 1; i < 10; i++)

  1087 #endif

  1088 		{

  1089 		__UHEAP_MARK;

  1090 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

  1091 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

  1092 #else

  1093         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1094 #endif

  1095 		TRAP(error, ExifCreate104L());

  1096 		if(error)

  1097 			{

  1098 			if(error != KErrNoMemory)

  1099 				{

  1100 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1101 				User::Leave(KErrGeneral);

  1102 				}

  1103 			}

  1104 		else

  1105 			{

  1106 			__UHEAP_MARKEND;

  1107 			break;

  1108 			}

  1109 		__UHEAP_MARKEND;

  1110 		}

  1111 

  1112 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

  1113 	for(i = 1; i < 500; i++)

  1114 #else

  1115     for(i = 1; i < 10; i++)

  1116 #endif

  1117 		{

  1118 		__UHEAP_MARK;

  1119 #if ( ( defined __WINS__ ) || ( defined __WINSCW__) )

  1120 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

  1121 #else

  1122         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1123 #endif

  1124 		TRAP(error, ExifCreate105L());

  1125 		if(error)

  1126 			{

  1127 			if(error != KErrNoMemory)

  1128 				{

  1129 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1130 				User::Leave(KErrGeneral);

  1131 				}

  1132 			}

  1133 		else

  1134 			{