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.001

    21 // Instantiate an Exif modifier with valid Jpeg image

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

    23 void CExifCreateTest::ExifCreate001L()

    24 	{

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

    26 	CleanupStack::PushL(jpeg);

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

    28 	if(!modify)

    29 		User::Leave(KErrGeneral);

    30 	delete modify;

    31 	CleanupStack::PopAndDestroy(jpeg);

    32 	}

    33 

    34 // Exif.Create.002

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

    36 // Leaves with proper error code.

    37 void CExifCreateTest::ExifCreate002L()

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

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

    47         {

    48         if ( modify )

    49             {

    50             delete modify;

    51             }

    52         if ( error )

    53             {

    54 		    User::Leave( error );

    55             }

    56         User::Leave( KErrGeneral );

    57         }

    58 	CleanupStack::PopAndDestroy( jpeg );

    59 

    60     // No SOI

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

    62 	CleanupStack::PushL( jpeg );

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

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

    65         {

    66         if ( modify )

    67             {

    68             delete modify;

    69             }

    70         if ( error )

    71             {

    72 		    User::Leave( error );

    73             }

    74         User::Leave( KErrGeneral );

    75         }

    76 	CleanupStack::PopAndDestroy( jpeg );

    77 

    78     // No EOI

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

    80 	CleanupStack::PushL( jpeg );

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

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

    83         {

    84         if ( modify )

    85             {

    86             delete modify;

    87             }

    88         if ( error )

    89             {

    90 		    User::Leave( error );

    91             }

    92         User::Leave( KErrGeneral );

    93         }

    94 	CleanupStack::PopAndDestroy( jpeg );

    95 

    96 	jpeg = TUtils::CreateDummyBufL( 120000 );

    97     CleanupStack::PushL( jpeg );

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

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

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

   101     delete jpeg2;

   102     jpeg2 = 0;

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

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

   105         {

   106         if ( modify )

   107             {

   108             delete modify;

   109             }

   110         if ( error )

   111             {

   112 		    User::Leave( error );

   113             }

   114         User::Leave( KErrGeneral );

   115         }

   116 	CleanupStack::PopAndDestroy( jpeg );

   117     }

   118 

   119 // Exif.Create.003

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

   121 // Returns unmodifiable reader instance.

   122 void CExifCreateTest::ExifCreate003L()

   123 	{

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

   125 	CleanupStack::PushL(jpeg);

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

   127 	CleanupStack::PushL(modify);

   128 

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

   130 	if(!reader)

   131 		User::Leave(KErrGeneral);

   132 

   133 	CleanupStack::PopAndDestroy(modify);

   134 	CleanupStack::PopAndDestroy(jpeg);

   135 	}

   136 

   137 // Exif.Create.004

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

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

   140 void CExifCreateTest::ExifCreate004L()

   141 	{

   142 //For each IFD.

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

   144 	CleanupStack::PushL(jpeg);

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

   146 	CleanupStack::PushL(modify);

   147 

   148 

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

   150 	CleanupStack::PushL(buf);

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

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

   153 	CleanupStack::PopAndDestroy(buf);

   154 

   155 	buf = TUtils::CreateDummyBufL(20);

   156 	CleanupStack::PushL(buf);

   157 	tag.iId = KIdUserComment;

   158 	tag.iDataType = CExifTag::ETagUndefined;

   159 	tag.iDataCount = 20; 

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

   161 	CleanupStack::PopAndDestroy(buf);

   162 

   163 	buf = TUtils::CreateDummyBufL(2);

   164 	CleanupStack::PushL(buf);

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

   166 	tag.iId = KIdExposureProgram;

   167 	tag.iDataType = CExifTag::ETagShort;

   168 	tag.iDataCount = 1;

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

   170 	CleanupStack::PopAndDestroy(buf);

   171 

   172 	buf = TUtils::CreateDummyBufL(1);

   173 	CleanupStack::PushL(buf);

   174 	tag.iId = 3;

   175 	tag.iDataType = CExifTag::ETagAscii;

   176 	tag.iDataCount = 1;

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

   178 	CleanupStack::PopAndDestroy(buf);

   179 

   180 	buf = TUtils::CreateDummyBufL(3);

   181 	CleanupStack::PushL(buf);

   182 	tag.iId = 1;

   183 	tag.iDataType = CExifTag::ETagAscii;

   184 	tag.iDataCount = 3;

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

   186 	CleanupStack::PopAndDestroy(buf);

   187 

   188 	buf = TUtils::CreateDummyBufL(2);

   189 	CleanupStack::PushL(buf);

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

   191 	tag.iId = KIdResolutionUnit;

   192 	tag.iDataType = CExifTag::ETagShort;

   193 	tag.iDataCount = 1; 

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

   195 	CleanupStack::PopAndDestroy(buf);

   196 

   197 	CleanupStack::PopAndDestroy(modify);

   198 	CleanupStack::PopAndDestroy(jpeg);	

   199 	}

   200 

   201 // Exif.Create.005

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

   203 // Leaves with proper error code.

   204 void CExifCreateTest::ExifCreate005L()

   205 	{

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

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

   208 	CleanupStack::PushL(jpeg);

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

   210 	CleanupStack::PushL(modify);

   211 

   212 

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

   214 	CleanupStack::PushL(buf);

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

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

   217 	if(error != KErrNotSupported)

   218 	{

   219 		if(error)

   220 			User::Leave(error);

   221 		User::Leave(KErrGeneral);

   222 	}

   223 	CleanupStack::PopAndDestroy(buf);

   224 

   225 	buf = TUtils::CreateDummyBufL(20);

   226 	CleanupStack::PushL(buf);

   227 	tag.iId = KIdUserComment;

   228 	tag.iDataType = CExifTag::ETagUndefined;

   229 	tag.iDataCount = 20; 

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

   231 	if(error != KErrNotSupported)

   232 	{

   233 		if(error)

   234 			User::Leave(error);

   235 		User::Leave(KErrGeneral);

   236 	}

   237 	CleanupStack::PopAndDestroy(buf);

   238 

   239 	buf = TUtils::CreateDummyBufL(2);

   240 	CleanupStack::PushL(buf);

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

   242 	tag.iId = KIdExposureProgram;

   243 	tag.iDataType = CExifTag::ETagShort;

   244 	tag.iDataCount = 1; 

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

   246 	if(error != KErrNotSupported)

   247 	{

   248 		if(error)

   249 			User::Leave(error);

   250 		User::Leave(KErrGeneral);

   251 	}

   252 	CleanupStack::PopAndDestroy(buf);

   253 

   254 	buf = TUtils::CreateDummyBufL(2);

   255 	CleanupStack::PushL(buf);

   256 	tag.iId = 3;

   257 	tag.iDataType = CExifTag::ETagAscii;

   258 	tag.iDataCount = 2; 

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

   260 	if(error != KErrNotSupported)

   261 	{

   262 		if(error)

   263 			User::Leave(error);

   264 		User::Leave(KErrGeneral);

   265 	}

   266 

   267 	CleanupStack::PopAndDestroy(buf);

   268 

   269 	buf = TUtils::CreateDummyBufL(3);

   270 	CleanupStack::PushL(buf);

   271 	tag.iId = 1;

   272 	tag.iDataType = CExifTag::ETagAscii;

   273 	tag.iDataCount = 3; 

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

   275 	if(error != KErrNotSupported)

   276 	{

   277 		if(error)

   278 			User::Leave(error);

   279 		User::Leave(KErrGeneral);

   280 	}

   281 	CleanupStack::PopAndDestroy(buf);

   282 

   283 	buf = TUtils::CreateDummyBufL(2);

   284 	CleanupStack::PushL(buf);

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

   286 	tag.iId = KIdResolutionUnit;

   287 	tag.iDataType = CExifTag::ETagShort;

   288 	tag.iDataCount = 1; 

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

   290 	if(error != KErrNotSupported)

   291 	{

   292 		if(error)

   293 			User::Leave(error);

   294 		User::Leave(KErrGeneral);

   295 	}

   296 	CleanupStack::PopAndDestroy(buf);

   297 

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

   299 

   300 	buf = TUtils::CreateDummyBufL(66000);

   301 	CleanupStack::PushL(buf);

   302 	tag.iId = 8;

   303 	tag.iDataType = CExifTag::ETagAscii;

   304 	tag.iDataCount = 66000; 

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

   306 	if(error != KErrOverflow)

   307 	{

   308 		if(error)

   309 			User::Leave(error);

   310 		User::Leave(KErrGeneral);

   311 	}

   312 	CleanupStack::PopAndDestroy(buf);

   313 

   314 	// Tag ID is invalid,	

   315 	buf = TUtils::CreateDummyBufL(19);

   316 	CleanupStack::PushL(buf);

   317 	tag.iId = 200;

   318 	tag.iDataType = CExifTag::ETagAscii;

   319 	tag.iDataCount = 19; 

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

   321 	if(error != KErrNotSupported)

   322 	{

   323 		if(error)

   324 			User::Leave(error);

   325 		User::Leave(KErrGeneral);

   326 	}

   327 	CleanupStack::PopAndDestroy(buf);

   328 

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

   330 	//* Not supported yet!!!

   331 	buf = TUtils::CreateDummyBufL(20);

   332 	CleanupStack::PushL(buf);

   333 	tag.iId = KIdImageDescription;

   334 	tag.iDataType = CExifTag::ETagByte;

   335 	tag.iDataCount = 20; 

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

   337 	if(error != KErrNotSupported)

   338         {

   339         if(error)

   340             User::Leave(error);

   341 		User::Leave(KErrGeneral);

   342         }

   343 	CleanupStack::PopAndDestroy(buf);

   344 	//*/

   345 

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

   347 	buf = TUtils::CreateDummyBufL(19);

   348 	CleanupStack::PushL(buf);

   349 	tag.iId = KIdImageDescription;

   350 	tag.iDataType = CExifTag::ETagAscii;

   351 	tag.iDataCount = 24; 

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

   353 	if(error != KErrArgument)

   354 	{

   355 		if(error)

   356 			User::Leave(error);

   357 		User::Leave(KErrGeneral);

   358 	}

   359 	CleanupStack::PopAndDestroy(buf);

   360 

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

   362     // !!! DROPPED !!!

   363 	/* Not supported yet!!!

   364 	buf = TUtils::CreateDummyBufL(2);

   365 	CleanupStack::PushL(buf);

   366 	tag.iId = KIdImageDescription;

   367 	tag.iDataType = CExifTag::ETagShort;

   368 	tag.iDataCount = 2; 

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

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

   371 	if(error != KErrArgument)

   372 	{

   373 		if(error)

   374 			User::Leave(error);

   375 		User::Leave(KErrGeneral);

   376 	}

   377 	CleanupStack::PopAndDestroy(buf);

   378     */

   379 

   380     // Data length = 0

   381     buf = TUtils::CreateDummyBufL(2);

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

   383 	CleanupStack::PushL(buf);

   384 	tag.iId = KIdImageDescription;

   385 	tag.iDataType = CExifTag::ETagShort;

   386 	tag.iDataCount = 2; 

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

   388 	TRAP(error, modify->SetTagL(EIfdExif, 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 	CleanupStack::PopAndDestroy(modify);

   398 	CleanupStack::PopAndDestroy(jpeg);	

   399 	}

   400 

   401 // Exif.Create.06

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

   403 // Inserts/ Updates the Exif thumbnail image

   404 void CExifCreateTest::ExifCreate006L()

   405 	{

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

   407 	CleanupStack::PushL(jpeg);

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

   409 	CleanupStack::PushL(modify);

   410 

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

   412 	CleanupStack::PushL(thumbnail);

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

   414 	CleanupStack::PopAndDestroy(thumbnail);

   415 

   416 	CleanupStack::PopAndDestroy(modify);

   417 	CleanupStack::PopAndDestroy(jpeg);	

   418 	}

   419 

   420 // Exif.Create.007

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

   422 // Leaves with proper error code.

   423 void CExifCreateTest::ExifCreate007L()

   424 	{

   425 	TInt error = 0;

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

   427 	CleanupStack::PushL(jpeg);

   428     CExifModify* modify = 0;

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

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

   431 	CleanupStack::PushL(modify);

   432 

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

   434 	CleanupStack::PushL(buf);

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

   436     if ( error != KErrCorrupt )

   437         {

   438         if ( error )

   439             {

   440             User::Leave( error );

   441             }

   442         User::Leave( KErrGeneral );

   443         }

   444     CleanupStack::PopAndDestroy( buf );

   445     

   446 

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

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

   449     buf = TUtils::CreateDummyBufL(60000);

   450 	CleanupStack::PushL(buf);

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

   452 	CleanupStack::PopAndDestroy(buf);

   453 

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

   455 	CleanupStack::PushL(thumbnail);

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

   457     if ( error != KErrOverflow )

   458         {

   459         if ( error )

   460             {

   461             User::Leave( error );

   462             }

   463         User::Leave( KErrGeneral );

   464         }

   465 	CleanupStack::PopAndDestroy(thumbnail);

   466 

   467 	CleanupStack::PopAndDestroy(modify);

   468 	CleanupStack::PopAndDestroy(jpeg);	

   469 	}

   470 

   471 // Exif.Create.008

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

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

   474 void CExifCreateTest::ExifCreate008L()

   475 	{

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

   477 	CleanupStack::PushL(jpeg);

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

   479 	CleanupStack::PushL(modify);

   480 

   481 	// Insert Tags

   482 	HBufC8* buf = 0;

   483 	TUint16 tmp1 = 0;

   484 	TUint32 tmp3 = 0;

   485 	TUint32 tmp4 = 0;

   486 

   487 	tmp3 = 72;

   488 	tmp4 = 1;

   489 	modify->SetXResolutionL(tmp3, tmp4);

   490 	modify->SetYResolutionL(tmp3, tmp4);

   491 	tmp1 = 2;

   492 	modify->SetResolutionUnitL(tmp1);

   493 	tmp1 = 1;

   494 	modify->SetYCbCrPositioningL(tmp1);

   495 

   496 	tmp3 = 0x1230;

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

   498 	tmp1 = 1;

   499 	modify->SetColorSpaceL(tmp1);

   500 	tmp3 = 1024;

   501 	modify->SetPixelXDimensionL(tmp3);

   502 	tmp3 = 768;

   503 	modify->SetPixelYDimensionL(tmp3);

   504 

   505 

   506 	buf = TUtils::CreateDummyBufL(5);

   507 	CleanupStack::PushL(buf);

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

   509 	CleanupStack::PopAndDestroy(buf);

   510 	buf = 0;

   511 

   512 	

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

   514 	CleanupStack::PushL(buf);

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

   516 	CleanupStack::PopAndDestroy(buf);

   517 	buf = 0;

   518 	

   519 	modify->SetExposureModeL(0);

   520 	modify->SetWhiteBalanceL(0);

   521 	modify->SetSceneCaptureTypeL(0);

   522 	modify->SetExposureProgramL(0);

   523 	

   524 	modify->SetLightSourceL(0);

   525 

   526 	buf = TUtils::CreateDummyBufL(16);

   527 	CleanupStack::PushL(buf);

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

   529 	CleanupStack::PopAndDestroy(buf);

   530 	buf = 0;

   531 

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

   533 	if(!buffer)

   534         User::Leave(KErrGeneral);

   535 	delete buffer;

   536 	buffer = 0;

   537 

   538     TPtrC8 tmpDes;

   539     buffer = modify->WriteDataL( tmpDes );

   540 	if(!buffer)

   541         User::Leave(KErrGeneral);

   542 	delete buffer;

   543 

   544 	CleanupStack::PopAndDestroy(modify);

   545 	CleanupStack::PopAndDestroy(jpeg);	

   546 	}

   547 

   548 

   549 // Exif.Create.009

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

   551 // Leaves with proper error code.

   552 void CExifCreateTest::ExifCreate009L()

   553 	{

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

   555 	CleanupStack::PushL(jpeg);

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

   557 	CleanupStack::PushL(modify);

   558 

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

   560     TInt error = 0;

   561 	HBufC8* buf = 0;

   562     HBufC8* buffer = 0;

   563     

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

   565     CleanupStack::PushL( buf );

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

   567     

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

   569         {

   570         if ( buffer )

   571             delete buffer;

   572         if ( error )

   573             {

   574             User::Leave( error );

   575             }

   576         User::Leave( KErrGeneral );

   577         }

   578     CleanupStack::PopAndDestroy( buf );

   579 

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

   581 

   582 	// Insert Tags

   583 	TUint16 tmp1 = 0;

   584 	TUint32 tmp3 = 0;

   585 	TUint32 tmp4 = 0;

   586 

   587 	tmp3 = 72;

   588 	tmp4 = 1;

   589 	modify->SetXResolutionL(tmp3, tmp4);

   590 	tmp1 = 2;

   591 	modify->SetResolutionUnitL(tmp1);

   592 

   593 	tmp3 = 0x1230;

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

   595 	tmp1 = 1;

   596 	modify->SetColorSpaceL(tmp1);

   597 	tmp3 = 768;

   598 	modify->SetPixelYDimensionL(tmp3);

   599 

   600 

   601 	buf = TUtils::CreateDummyBufL(5);

   602 	CleanupStack::PushL(buf);

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

   604 	CleanupStack::PopAndDestroy(buf);

   605 	buf = 0;

   606 

   607 	

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

   609 	CleanupStack::PushL(buf);

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

   611 	CleanupStack::PopAndDestroy(buf);

   612 	buf = 0;

   613 	

   614 	modify->SetExposureModeL(0);

   615 	modify->SetWhiteBalanceL(0);

   616 	modify->SetSceneCaptureTypeL(0);

   617 	modify->SetExposureProgramL(0);

   618 	

   619 	modify->SetLightSourceL(0);

   620 

   621 	buf = TUtils::CreateDummyBufL(16);

   622 	CleanupStack::PushL(buf);

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

   624 	CleanupStack::PopAndDestroy(buf);

   625 	buf = 0;

   626 

   627 	buffer = 0;

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

   629 	if(buffer)

   630 		{

   631 		delete buffer;

   632 		User::Leave(KErrGeneral);

   633 		}

   634 	if(error != KErrNotReady)

   635 	    {

   636 		if(error)

   637 			User::Leave(error);

   638 		User::Leave(KErrGeneral);

   639 	    }

   640 

   641 	CleanupStack::PopAndDestroy(modify);

   642 	CleanupStack::PopAndDestroy(jpeg);	

   643 	}

   644 

   645 // Exif.Create.010

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

   647 // Inserts/ Updates the tag data

   648 void CExifCreateTest::ExifCreate010L()

   649 	{

   650 //For each Set function.

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

   652 	CleanupStack::PushL(jpeg);

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

   654 	CleanupStack::PushL(modify);

   655 

   656 	// For some Set functions.

   657 	// Insert Tags

   658 	HBufC8* buf = 0;

   659     TUint16 tmp1 = 0;

   660 	TUint32 tmp3 = 0;

   661 	TUint32 tmp4 = 0;

   662     TInt32 tmp5 = 0;

   663     TInt32 tmp6 = 0;

   664 

   665 	buf = TUtils::CreateDummyBufL(10);

   666 	CleanupStack::PushL(buf);

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

   668 	CleanupStack::PopAndDestroy(buf);

   669 	buf = 0;

   670 

   671 	buf = TUtils::CreateDummyBufL(4);

   672 	CleanupStack::PushL(buf);

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

   674 	CleanupStack::PopAndDestroy(buf);

   675 	buf = 0;

   676 

   677     tmp1 = 0;

   678     modify->SetMeteringModeL(tmp1);

   679 

   680     tmp5 = 1;

   681     tmp6 = 1;

   682     modify->SetExposureBiasValueL(tmp5, tmp6);

   683 

   684 	buf = TUtils::CreateDummyBufL(19);

   685 	CleanupStack::PushL(buf);

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

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

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

   689 	CleanupStack::PopAndDestroy(buf);

   690 	buf = 0;

   691 

   692     tmp5 = 1;

   693     tmp6 = 1;

   694     modify->SetApertureValueL(tmp5, tmp6);

   695     

   696 	buf = TUtils::CreateDummyBufL(12);

   697 	CleanupStack::PushL(buf);

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

   699 	CleanupStack::PopAndDestroy(buf);

   700 

   701 	buf = TUtils::CreateDummyBufL(12);

   702 	CleanupStack::PushL(buf);

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

   704 	CleanupStack::PopAndDestroy(buf);

   705 

   706 	modify->SetOrientationL(1);

   707 	modify->SetExposureModeL(0);

   708 	modify->SetWhiteBalanceL(0);

   709 	modify->SetSceneCaptureTypeL(0);

   710 	modify->SetExposureProgramL(0);

   711 

   712 	tmp3 = 72;

   713 	tmp4 = 1;

   714 	modify->SetXResolutionL(tmp3, tmp4);

   715 	modify->SetThumbnailYResolutionL(tmp3, tmp4);

   716 	modify->SetFileSourceL(1); 

   717 	modify->SetSharpnessL(0); 

   718 

   719 	CleanupStack::PopAndDestroy(modify);

   720 	CleanupStack::PopAndDestroy(jpeg);	

   721 	}

   722 

   723 // Exif.Create.011

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

   725 // Leaves with or returns proper error code.

   726 void CExifCreateTest::ExifCreate011L()

   727 	{

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

   729 	CleanupStack::PushL(jpeg);

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

   731 	CleanupStack::PushL(modify);

   732 //"* Data size is invalid 

   733 	HBufC8* buf = 0;

   734 	buf = TUtils::CreateDummyBufL(700);

   735 	CleanupStack::PushL(buf);

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

   737 	if(error != KErrNotSupported)

   738 	{

   739 		if(error)

   740 			User::Leave(error);

   741 		User::Leave(KErrGeneral);

   742 	}

   743 	CleanupStack::PopAndDestroy(buf);

   744 

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

   746     // !!! DROPPED !!!

   747 

   748 	CleanupStack::PopAndDestroy(modify);

   749 	CleanupStack::PopAndDestroy(jpeg);	

   750 	}

   751 

   752 // Exif.Create.012

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

   754 // Leaves with or returns proper error code.

   755 // CHANGED:

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

   757 void CExifCreateTest::ExifCreate012L()

   758 	{

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

   760 	CleanupStack::PushL(jpeg);

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

   762 	CleanupStack::PushL(modify);

   763 

   764 	// Insert Tags

   765 	TUint16 tmp1 = 0;

   766 	TUint32 tmp3 = 0;

   767 	TUint32 tmp4 = 0;

   768 

   769     modify->SetYCbCrPositioningL(2);

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

   771 	tmp1 = 1;

   772 	modify->SetColorSpaceL(tmp1);

   773 	tmp3 = 480;

   774 	modify->SetPixelYDimensionL(tmp3);

   775 

   776 	tmp3 = 72;

   777 	tmp4 = 1;

   778 	modify->SetXResolutionL(tmp3, tmp4);

   779     modify->SetYResolutionL(tmp3, tmp4);

   780 	tmp1 = 2;

   781 	modify->SetResolutionUnitL(tmp1);

   782 

   783     HBufC8* buffer = NULL;

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

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

   786         {

   787         if( buffer )

   788             delete buffer;

   789         buffer = 0;

   790         if( error )

   791             {

   792             User::Leave( error);

   793             }

   794         User::Leave( KErrGeneral );

   795         }

   796 

   797     TPtrC8 tmpDes;

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

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

   800         {

   801         if( buffer )

   802             delete buffer;

   803         buffer = 0;

   804         if( error )

   805             {

   806             User::Leave( error);

   807             }

   808         User::Leave( KErrGeneral );

   809         }

   810 

   811     modify->SetPixelXDimensionL(640);

   812     

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

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

   815         {

   816         if( buffer )

   817             delete buffer;

   818         buffer = 0;

   819         if( error )

   820             {

   821             User::Leave( error);

   822             }

   823         User::Leave( KErrGeneral );

   824         }

   825     delete buffer;

   826     buffer = 0;

   827 

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

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

   830         {

   831         if( buffer )

   832             delete buffer;

   833         buffer = 0;

   834         if( error )

   835             {

   836             User::Leave( error);

   837             }

   838         User::Leave( KErrGeneral );

   839         }

   840 

   841     CleanupStack::PushL(buffer);

   842     RFile file;

   843 	TBuf<255> fileName;

   844     fileName.Copy(KRootOut);

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

   846 

   847 	// Create out folder, ignore errors

   848 	iFs.MkDir(fileName);

   849 	

   850 	fileName.Append(_L("Create12_01.jpg"));

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

   852         {

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

   854             {

   855             fileName.Copy(KRootC);

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

   857         	// Create out folder, ignore errors

   858 	        iFs.MkDir(fileName);

   859 	        fileName.Append(_L("Create12_01.jpg"));

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

   861                 {

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

   863                     {

   864                     fileName.Copy(KRootData);

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

   866                 	// Create out folder, ignore errors

   867 	                iFs.MkDir(fileName);

   868 	                fileName.Append(_L("Create12_01.jpg"));

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

   870                         {

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

   872                         }

   873                     }

   874                 }

   875             }

   876         }

   877  

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

   879     file.Close();

   880     CleanupStack::PopAndDestroy(buffer);

   881     buffer = 0;

   882 

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

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

   885         {

   886         if( buffer )

   887             delete buffer;

   888         buffer = 0;

   889         if( error )

   890             {

   891             User::Leave( error);

   892             }

   893         User::Leave( KErrGeneral );

   894         }

   895     delete buffer;

   896     buffer = 0;

   897 

   898 

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

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

   901         {

   902         if( buffer )

   903             delete buffer;

   904         buffer = 0;

   905         if( error )

   906             {

   907             User::Leave( error);

   908             }

   909         User::Leave( KErrGeneral );

   910         }

   911 

   912     CleanupStack::PushL(buffer);

   913     fileName.Copy(KRootOut);

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

   915 	// Create out folder, ignore errors

   916 	iFs.MkDir(fileName);

   917 	fileName.Append(_L("Create12_02.jpg"));

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

   919         {

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

   921             {

   922             fileName.Copy(KRootC);

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

   924 	        // Create out folder, ignore errors

   925         	iFs.MkDir(fileName);

   926 	        fileName.Append(_L("Create12_02.jpg"));

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

   928                 {

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

   930                     {

   931                     fileName.Copy(KRootData);

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

   933                 	// Create out folder, ignore errors

   934 	                iFs.MkDir(fileName);

   935 	                fileName.Append(_L("Create12_02.jpg"));

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

   937                         {

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

   939                         }

   940                     }

   941                 }

   942             }

   943         }

   944  

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

   946     file.Close();

   947     CleanupStack::PopAndDestroy(buffer);

   948     buffer = 0;

   949 

   950     modify->DeleteTag(EIfdExif, KIdPixelXDimension);

   951 

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

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

   954         {

   955         if( buffer )

   956             delete buffer;

   957         buffer = 0;

   958         if( error )

   959             {

   960             User::Leave( error);

   961             }

   962         User::Leave( KErrGeneral );

   963         }    

   964 

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

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

   967         {

   968         if( buffer )

   969             delete buffer;

   970         buffer = 0;

   971         if( error )

   972             {

   973             User::Leave( error);

   974             }

   975         User::Leave( KErrGeneral );

   976         }    

   977 

   978 	CleanupStack::PopAndDestroy(modify);

   979 	CleanupStack::PopAndDestroy(jpeg);	

   980 	}

   981 

   982 // Exif.Create.MEM.013

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

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

   985 void CExifCreateTest::ExifCreate013L()

   986 	{

   987 //OOM in EXIF.CREATE.001- EXIF.CREATE.012

   988 	TInt error = KErrGeneral;

   989 	TInt i = 0;

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

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

   992 #else

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

   994 #endif

   995 		{

   996 		__UHEAP_MARK;

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

   998 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

   999 #else

  1000         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1001 #endif

  1002 		TRAP(error, ExifCreate001L());

  1003 		if(error)

  1004 			{

  1005 			if(error != KErrNoMemory)

  1006 				{

  1007 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1008 				User::Leave(KErrGeneral);

  1009 				}

  1010 			}

  1011 		else

  1012 			{

  1013 			__UHEAP_MARKEND;

  1014 			break;

  1015 			}

  1016 		__UHEAP_MARKEND;

  1017 		}

  1018 

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

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

  1021 #else

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

  1023 #endif

  1024 		{

  1025 		__UHEAP_MARK;

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

  1027 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

  1028 #else

  1029         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1030 #endif

  1031 		TRAP(error, ExifCreate002L());

  1032 		if(error)

  1033 			{

  1034 			if(error != KErrNoMemory)

  1035 				{

  1036 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1037 				User::Leave(KErrGeneral);

  1038 				}

  1039 			}

  1040 		else

  1041 			{

  1042 			__UHEAP_MARKEND;

  1043 			break;

  1044 			}

  1045 		__UHEAP_MARKEND;

  1046 		}

  1047 

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

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

  1050 #else

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

  1052 #endif

  1053 		{

  1054 		__UHEAP_MARK;

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

  1056 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

  1057 #else

  1058         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1059 #endif

  1060 		TRAP(error, ExifCreate003L());

  1061 		if(error)

  1062 			{

  1063 			if(error != KErrNoMemory)

  1064 				{

  1065 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1066 				User::Leave(KErrGeneral);

  1067 				}

  1068 			}

  1069 		else

  1070 			{

  1071 			__UHEAP_MARKEND;

  1072 			break;

  1073 			}

  1074 		__UHEAP_MARKEND;

  1075 		}

  1076 

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

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

  1079 #else

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

  1081 #endif

  1082 		{

  1083 		__UHEAP_MARK;

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

  1085 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

  1086 #else

  1087         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1088 #endif

  1089 		TRAP(error, ExifCreate004L());

  1090 		if(error)

  1091 			{

  1092 			if(error != KErrNoMemory)

  1093 				{

  1094 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1095 				User::Leave(KErrGeneral);

  1096 				}

  1097 			}

  1098 		else

  1099 			{

  1100 			__UHEAP_MARKEND;

  1101 			break;

  1102 			}

  1103 		__UHEAP_MARKEND;

  1104 		}

  1105 

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

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

  1108 #else

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

  1110 #endif

  1111 		{

  1112 		__UHEAP_MARK;

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

  1114 		__UHEAP_SETFAIL( RHeap::EFailNext, i );

  1115 #else

  1116         __UHEAP_SETFAIL( RHeap::ERandom, i );

  1117 #endif

  1118 		TRAP(error, ExifCreate005L());

  1119 		if(error)

  1120 			{

  1121 			if(error != KErrNoMemory)

  1122 				{

  1123 				__UHEAP_SETFAIL( RHeap::ENone, 0 );

  1124 				User::Leave(KErrGeneral);

  1125 				}

  1126 			}

  1127 		else

  1128 			{

  1129 			__UHEAP_MARKEND;

  1130 			break;

  1131 			}

  1132 		__UHEAP_MARKEND;

  1133 		}

  1134 

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