1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <mmf/common/mmferrors.h>

    17 #include <caf/caf.h>

    18 using namespace ContentAccess;

    19 #include "tsu3gplibraryapinegative.h"

    20 

    21 // --------------------------

    22 // C3GPLibParser_Negative 

    23 // --------------------------

    24 //

    25 void C3GPLibParser_Negative::CallAudioApiL(C3GPParse* aParse, TInt aExpectedError)

    26 	{

    27 	TInt err = KErrNone;

    28 	// Retrieve audio stream attributes

    29 	T3GPAudioType audioType;

    30 	TInt framesPerSample;

    31 	TUint length; 

    32 	TUint avgBitRate;

    33 	TUint timeScale;

    34 		

    35 	err = aParse->GetAudioProperties(audioType, length, framesPerSample, avgBitRate, timeScale);

    36 	User::LeaveIfError(CheckError(err, aExpectedError, _L("aParse->GetAudioProperties")));

    37 

    38 	TBool available;

    39 	T3GPFrameType type = E3GPAudio;

    40 	err = aParse->GetFrameAvailability(type, available);

    41 	if (aExpectedError == KErrNotSupported)

    42 		{

    43 		// GetFrameAvailability will return KErrNotFound when there is no audio in the 3gp files

    44 		User::LeaveIfError(CheckError(err, KErrNotFound, _L("GetFrameAvailability")));

    45 		}

    46 	else

    47 		{

    48 		User::LeaveIfError(CheckError(err, aExpectedError, _L("GetFrameAvailability")));

    49 		}

    50 	

    51 	TUint size;

    52 	err = aParse->GetAudioFramesSize(size);

    53 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetAudioFramesSize")));

    54 	

    55 	RBuf8 buffer;

    56 	CleanupClosePushL(buffer);

    57 	

    58 	if (aExpectedError == KErrNone)

    59 		{

    60 		buffer.CreateL(size); // Use size retrieved from GetVideoFrameSize

    61 		}

    62 	else

    63 		{

    64 		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

    65 		}

    66 	

    67 	TUint timeStampInMs; 

    68 	TUint timeStampInTimescale;

    69 	TInt returnedFrames;

    70 	err = aParse->ReadAudioFrames(buffer, returnedFrames, timeStampInMs, timeStampInTimescale);

    71 	User::LeaveIfError(CheckError(err, aExpectedError, _L("ReadAudioFrames")));

    72 	CleanupStack::PopAndDestroy(&buffer);

    73 	

    74 	TUint index;

    75 	err = aParse->GetAudioSampleEntryIndex(index);

    76 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetAudioSampleEntryIndex")));

    77 	

    78 	T3GPQcelpStorageMode mode;

    79 	err = aParse->GetQcelpStorageMode(mode);

    80 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetQcelpStorageMode")));

    81 	}

    82 

    83 void C3GPLibParser_Negative::CallVideoApiL(C3GPParse* aParse, TInt aExpectedError)

    84 	{

    85 	TInt err = KErrNone;

    86 	// Retrieve video & audio stream attributes

    87 	T3GPVideoType videoType;

    88 	TUint length; 

    89 	TReal frameRate;

    90 	TUint avgBitRate;

    91 	TSize videoSize;

    92 	TUint timeScale;

    93 	

    94 	err = aParse->GetVideoProperties(videoType, length, frameRate, avgBitRate, videoSize, timeScale);

    95 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoProperties")));

    96 	

    97 	TBool available;

    98 	T3GPFrameType type = E3GPVideo;

    99 	err = aParse->GetFrameAvailability(type, available);

   100 	if (aExpectedError == KErrNotSupported)

   101 		{

   102 		// GetFrameAvailability will return KErrNotFound when there is no video in the 3gp files

   103 		User::LeaveIfError(CheckError(err, KErrNotFound, _L("GetFrameAvailability")));

   104 		}

   105 	else

   106 		{

   107 		User::LeaveIfError(CheckError(err, aExpectedError, _L("GetFrameAvailability")));

   108 		}

   109 	

   110 	TUint size;	

   111 	err = aParse->GetVideoFrameSize(size);

   112 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameSize")));

   113 		

   114 	RBuf8 buffer;

   115 	CleanupClosePushL(buffer);

   116 	if (aExpectedError == KErrNone)

   117 		{

   118 		buffer.CreateL(size); // Use size retrieved from GetVideoFrameSize

   119 		}

   120 	else

   121 		{

   122 		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

   123 		}

   124 	TBool keyFrame;

   125 	TUint timeStampInMs; 

   126 	TUint timeStampInTimescale;

   127 	err = aParse->ReadVideoFrame(buffer, keyFrame, timeStampInMs, timeStampInTimescale);

   128 	User::LeaveIfError(CheckError(err, aExpectedError, _L("ReadVideoFrame")));

   129 	CleanupStack::PopAndDestroy(&buffer);

   130 	

   131 	err = aParse->GetVideoTimestamp(timeStampInMs, timeStampInTimescale);

   132 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoTimestamp")));

   133 

   134 	TUint num;

   135 	err = aParse->GetNumberOfVideoFrames(num);

   136 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetNumberOfVideoFrames")));

   137 	

   138 	TUint index;

   139 	err = aParse->GetVideoSampleEntryIndex(index);

   140 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoSampleEntryIndex")));

   141 	

   142 	err = aParse->GetVideoFrameSize(index, size);

   143 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameSize")));

   144 	

   145 	err = aParse->GetVideoFrameStartTime(index, timeStampInMs, timeStampInTimescale);

   146 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameStartTime")));

   147 	

   148 	err = aParse->GetVideoFrameKeyType(index, keyFrame);

   149 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameKeyType")));

   150 	

   151 	TInt level;

   152 	err = aParse->GetH263VideoLevel(level);

   153 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetH263VideoLevel")));

   154 	

   155 	T3GPFrameDependencies dependencies;

   156 	err = aParse->GetVideoFrameDependencies(dependencies);

   157 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameDependencies")));

   158 	

   159 	TUint numberOfFrames = 2;

   160 	RArray<T3GPFrameInfoParameters> array;

   161 	err = aParse->GetVideoFrameProperties(index, numberOfFrames, array);

   162 	array.Close();

   163 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoFrameProperties")));	

   164 	}

   165 

   166 void C3GPLibParser_Negative::CallVideoDecoderInfoApiL(C3GPParse* aParse, TInt aExpectedError)

   167 	{

   168 	RBuf8 buffer;

   169 	CleanupClosePushL(buffer);

   170 	

   171 	TInt dsiSize;

   172 	TInt err = aParse->GetVideoDecoderSpecificInfoSize(dsiSize);

   173 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoDecoderSpecificInfoSize")));

   174 	

   175 	if (aExpectedError == KErrNone)

   176 		{

   177 		buffer.CreateL(dsiSize);

   178 		}

   179 	else

   180 		{

   181 		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

   182 		}

   183 	err = aParse->GetVideoDecoderSpecificInfo(buffer);

   184 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetVideoDecoderSpecificInfo")));

   185 	

   186 	CleanupStack::PopAndDestroy(&buffer);

   187 	}

   188 

   189 void C3GPLibParser_Negative::CallAudioDecoderInfoApiL(C3GPParse* aParse, TInt aExpectedError)

   190 	{

   191 	RBuf8 buffer;

   192 	CleanupClosePushL(buffer);

   193 	TInt dsiSize;

   194 	TInt err = aParse->GetAudioDecoderSpecificInfoSize(dsiSize);

   195 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetAudioDecoderSpecificInfoSize")));

   196 	

   197 	if (aExpectedError == KErrNone)

   198 		{

   199 		buffer.CreateL(dsiSize);

   200 		}

   201 	else

   202 		{

   203 		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

   204 		}

   205 	err = aParse->GetAudioDecoderSpecificInfo(buffer);

   206 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetAudioDecoderSpecificInfo")));

   207 	

   208 	CleanupStack::PopAndDestroy(&buffer);

   209 	}

   210 

   211 // Retrieve user data atom. 

   212 void C3GPLibParser_Negative::CallUDTApiL(C3GPParse* aParse, TUint32 aUdtType, TUint& aIndex, TInt aExpectedError, T3GPUdtaLocation aLocation)

   213 	{

   214 	TInt err = KErrNone;

   215 	TInt udtSize;

   216 	TUint tempIndex = aIndex;	// use the copy of the aIndex so it does not get overwritten by GetUserDataAtomSize

   217 

   218 	err = aParse->GetUserDataAtomSize(aUdtType, aLocation, tempIndex, udtSize);

   219 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetUserDataAtomSize")));

   220 	

   221 	RBuf8 buffer;	

   222 	CleanupClosePushL(buffer);

   223 	

   224 	if (aExpectedError == KErrNone && err == KErrNone)

   225 		{

   226 		buffer.CreateL(udtSize); // Use size retrieved from GetUserDataAtomSize

   227 		}

   228 	else

   229 		{

   230 		buffer.CreateL(KBufferSize); // size from above may not be assigned since this is negative tests.

   231 		}

   232 	err = aParse->GetUserDataAtom(aUdtType, aLocation, buffer, aIndex);

   233 	CleanupStack::PopAndDestroy(&buffer);

   234 	

   235 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetUserDataAtom")));

   236 	}

   237 

   238 void C3GPLibParser_Negative::CallCommonApiL(C3GPParse* aParse, TInt aExpectedError)

   239 	{

   240 	TInt err = KErrNone;

   241 	

   242 	TUint size;

   243 	TUint avgBitRate;

   244 	err = aParse->GetContainerProperties(size, avgBitRate);

   245 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetContainerProperties")));

   246 	

   247 	T3GPFrameType type;

   248 	err = aParse->C3GPParse::GetFrameType(type);

   249 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetFrameType")));

   250 	

   251 	TBool streamable;

   252 	err = aParse->GetStreamable(streamable);

   253 	User::LeaveIfError(CheckError(err, aExpectedError, _L("GetStreamable")));

   254 	

   255 	TUint position = 0;

   256 	TBool keyFrame = EFalse;

   257 	TUint audioPosition;

   258 	TUint videoPosition;

   259 	err = aParse->Seek(position, keyFrame, audioPosition, videoPosition);

   260 	User::LeaveIfError(CheckError(err, aExpectedError, _L("Seek")));

   261 	}

   262 

   263 // -----------------------------------------------------------------------------

   264 // Create 3GP Parser to read zero size file content and call all APIs except

   265 // asynchrounous read

   266 // -----------------------------------------------------------------------------

   267 //

   268 C3GPLibParser_0101::C3GPLibParser_0101()

   269 	{	

   270 	}

   271 

   272 TVerdict C3GPLibParser_0101::doTestStepL()

   273 	{

   274 	if(TestStepResult() == EPass)

   275 		{

   276 		C3GPParse* parser = C3GPParse::NewL();

   277 		CleanupStack::PushL(parser);

   278 		

   279 		TRAPD(err, EmptyFileFailedCorruptL(parser));

   280 		if (err != KErrNone)

   281 			{

   282 			SetTestStepResult(EFail);

   283 			}

   284 		

   285 		CleanupStack::PopAndDestroy(parser);

   286 		}

   287 	return TestStepResult();

   288 	}

   289 

   290 void C3GPLibParser_0101::EmptyFileFailedCorruptL(C3GPParse* aParse)

   291 	{

   292 	// all api test with empty file using file path

   293 	// When the parser is in use, calling parser open again should fail with KErrInUse

   294 	ParserOpenFileL(aParse, KErrInUse);

   295 	

   296 	CallCommonApiL(aParse, KErrCorrupt);

   297 	CallVideoApiL(aParse, KErrCorrupt);

   298 	CallAudioApiL(aParse, KErrCorrupt);

   299 	CallVideoDecoderInfoApiL(aParse, KErrCorrupt);

   300 	CallAudioDecoderInfoApiL(aParse, KErrCorrupt);

   301 	TUint32 udtType = 0x7469746c;

   302 	TUint index;

   303 	CallUDTApiL(aParse, udtType, index, KErrCorrupt);

   304 	T3GPUdtaLocation location = E3GPUdtaAudioTrak;

   305 	CallUDTApiL(aParse, udtType, index, KErrCorrupt, location);

   306 	ParserCompleteL(aParse);	

   307 	

   308 	// all api test with empty file using file handle

   309 	// When the parser is in use, calling parser open again should fail with KErrInUse

   310 	ParserOpenFileHandleL(aParse, EFileRead | EFileShareReadersOnly, KErrInUse);

   311 

   312 	CallCommonApiL(aParse, KErrCorrupt);

   313 	CallVideoApiL(aParse, KErrCorrupt);

   314 	CallAudioApiL(aParse, KErrCorrupt);

   315 	CallVideoDecoderInfoApiL(aParse, KErrCorrupt);

   316 	CallAudioDecoderInfoApiL(aParse, KErrCorrupt);

   317 	CallUDTApiL(aParse, udtType, index, KErrCorrupt);

   318 	CallUDTApiL(aParse, udtType, index, KErrCorrupt, location);

   319 	ParserCompleteHandleL(aParse);

   320 

   321 	// all api test with empty file using CAF

   322 	// When the parser is in use, calling parser open again should fail with KErrInUse

   323 	ParserOpenCafLC(aParse, KErrInUse);

   324 	

   325 	CallCommonApiL(aParse, KErrCorrupt);

   326 	CallVideoApiL(aParse, KErrCorrupt);

   327 	CallAudioApiL(aParse, KErrCorrupt);

   328 	CallVideoDecoderInfoApiL(aParse, KErrCorrupt);

   329 	CallAudioDecoderInfoApiL(aParse, KErrCorrupt);

   330 	CallUDTApiL(aParse, udtType, index, KErrCorrupt);

   331 	CallUDTApiL(aParse, udtType, index, KErrCorrupt, location);

   332 	ParserCompleteCafL(aParse);

   333 	

   334 	// test open using buffer mode

   335 	// When the parser is in use, calling parser open again should fail with KErrInUse

   336 	ParserOpenL(aParse, KErrInUse);

   337 	ParserCompleteL(aParse);

   338 	// Call complete again, should pass with no error

   339 	ParserCompleteL(aParse);

   340 	}

   341 

   342 // -----------------------------------------------------------------------------

   343 // Initialise a 3GP file parse with an empty filename and file path pointing 

   344 // at non-existent files

   345 // -----------------------------------------------------------------------------

   346 //

   347 C3GPLibParser_0102::C3GPLibParser_0102()

   348 	{	

   349 	}

   350 

   351 TVerdict C3GPLibParser_0102::doTestStepL()

   352 	{

   353 	if(TestStepResult() == EPass)

   354 		{

   355 		C3GPParse* parser = C3GPParse::NewL();

   356 		CleanupStack::PushL(parser);

   357 		

   358 		// Initialise a 3GP file parse with an empty filename and it should fail with KErrUnderflow

   359 		TInt err = parser->Open(KEmptyFileString);		

   360 		if (err != KErrUnderflow)

   361 			{

   362 			ERR_PRINTF2(_L("parser->Open(KEmptyFileString) expects KErrUnderflow. Returns with %d"), err);

   363 			SetTestStepResult(EFail);

   364 			}

   365 		

   366 		// Setup 3GP Parser with a file path of a non-existing file.  This should fail with KErrAccessDenied.

   367 		err = parser->Open(KInvalidFileString);

   368 		if (err != KErrAccessDenied)

   369 			{

   370 			ERR_PRINTF2(_L("parser->Open(KEmptyFileString) expects KErrAccessDenied. Returns with %d"), err);

   371 			SetTestStepResult(EFail);

   372 			}

   373 		

   374 		CleanupStack::PopAndDestroy(parser);

   375 		}

   376 	return TestStepResult();

   377 	}

   378 

   379 // -----------------------------------------------------------------------------

   380 // Create parser by passing in a file path of a file already opened in 

   381 // EFileShareExclusive mode. 

   382 // -----------------------------------------------------------------------------

   383 //

   384 C3GPLibParser_0104::C3GPLibParser_0104()

   385 	{	

   386 	}

   387 

   388 TVerdict C3GPLibParser_0104::doTestStepL()

   389 	{

   390 	if(TestStepResult() == EPass)

   391 		{

   392 		C3GPParse* parser = C3GPParse::NewL();

   393 		CleanupStack::PushL(parser);

   394 		

   395 		// Open a valid mp4/3gp/3g2 file with EFileShareExclusive mode

   396 		// Instantiate a 3GP parser object with the same file path already opened above

   397 		FileOpenL(EFileShareExclusive);

   398 		TInt err = parser->Open(iInputFile);

   399 		if (err != KErrAccessDenied)

   400 			{

   401 			ERR_PRINTF2(_L("parser->Open(iInputFile) expects KErrAccessDenied. Returns with %d"), err);

   402 			SetTestStepResult(EFail);

   403 			}

   404 		ParserCompleteL(parser);

   405 		FileClose();

   406 

   407 		CleanupStack::PopAndDestroy(parser);

   408 		}

   409 	return TestStepResult();

   410 	}

   411 

   412 // -----------------------------------------------------------------------------

   413 // Use 3GP Parser to parse file before it has been setup

   414 // -----------------------------------------------------------------------------

   415 //

   416 C3GPLibParser_0106::C3GPLibParser_0106()

   417 	{	

   418 	}

   419 

   420 TVerdict C3GPLibParser_0106::doTestStepL()

   421 	{

   422 	if(TestStepResult() == EPass)

   423 		{

   424 		C3GPParse* parser = C3GPParse::NewL();

   425 		CleanupStack::PushL(parser);

   426 

   427 		TRAPD(err, AllApiFailedNotReadyL(parser));

   428 		if (err != KErrNone)

   429 			{

   430 			SetTestStepResult(EFail);

   431 			}

   432 		

   433 		CleanupStack::PopAndDestroy(parser);

   434 		}

   435 	return TestStepResult();

   436 	}

   437 

   438 void C3GPLibParser_0106::AllApiFailedNotReadyL(C3GPParse* aParse)

   439 	{

   440 	CallCommonApiL(aParse, KErrNotReady);

   441 	CallVideoApiL(aParse, KErrNotReady);

   442 	CallAudioApiL(aParse, KErrNotReady);

   443 	CallVideoDecoderInfoApiL(aParse, KErrNotReady);

   444 	CallAudioDecoderInfoApiL(aParse, KErrNotReady);

   445 	TUint32 udtType = 0x7469746c;

   446 	TUint index;

   447 	CallUDTApiL(aParse, udtType, index, KErrNotReady);

   448 	

   449 	RBuf8 buffer;

   450 	CleanupClosePushL(buffer);

   451 	// create 0 size buffer for negative test when API is called before parse is opened

   452 	buffer.CreateL(0); 

   453 	TInt err = aParse->InsertData(buffer);

   454 	User::LeaveIfError(CheckError(err, KErrNotReady, _L("aParse->InsertData")));

   455 	CleanupStack::PopAndDestroy(&buffer);

   456 	

   457 	TInt num;

   458 	err = aParse->GetNumBufferedBytes(num);

   459 	User::LeaveIfError(CheckError(err, KErrNotReady, _L("aParse->InsertData")));

   460 	}

   461 

   462 // -----------------------------------------------------------------------------

   463 // Use invalid frame type for all frame type API.

   464 // -----------------------------------------------------------------------------

   465 //

   466 C3GPLibParser_0107::C3GPLibParser_0107()

   467 	{

   468 	}

   469 

   470 TVerdict C3GPLibParser_0107::doTestStepL()

   471 	{

   472 	if(TestStepResult() == EPass)

   473 		{

   474 		C3GPParse* parser = C3GPParse::NewL();

   475 		CleanupStack::PushL(parser);

   476 

   477 		TRAPD(err, InvalidFrameTypeL(parser));

   478 		if (err != KErrNone)

   479 			{

   480 			SetTestStepResult(EFail);

   481 			}

   482 		

   483 		CleanupStack::PopAndDestroy(parser);

   484 		}

   485 	return TestStepResult();

   486 	}

   487 

   488 void C3GPLibParser_0107::InvalidFrameTypeL(C3GPParse* aParse)

   489 	{

   490 	// file mode

   491 	ParserOpenFileL(aParse);

   492 	

   493 	// Invalid type tests

   494 	TInt invalidType = 10;	

   495 	T3GPVideoType invalidVideoType = static_cast<T3GPVideoType>(invalidType);

   496 	TUint length; 

   497 	TReal frameRate;

   498 	TUint avgBitRate;

   499 	TSize videoSize;

   500 	TUint timeScale;

   501 	 // should pass

   502 	TInt err = aParse->GetVideoProperties(invalidVideoType, length, frameRate, avgBitRate, videoSize, timeScale);

   503 	User::LeaveIfError(CheckError(err, KErrNone, _L("GetVideoProperties")));

   504 	

   505 	T3GPAudioType invalidAudioType = static_cast<T3GPAudioType>(invalidType);

   506 	TInt framesPerSample;

   507 	 // should pass

   508 	err = aParse->GetAudioProperties(invalidAudioType, length, framesPerSample, avgBitRate, timeScale);

   509 	User::LeaveIfError(CheckError(err, KErrNone, _L("aParse->GetAudioProperties")));

   510 	

   511 	T3GPFrameType invalidFrameType = static_cast<T3GPFrameType>(invalidType);

   512 	// should pass

   513 	err = aParse->GetFrameType(invalidFrameType); 

   514 	User::LeaveIfError(CheckError(err, KErrNone, _L("aParse->GetAudioProperties")));

   515 	

   516 	T3GPQcelpStorageMode invalidMode = static_cast<T3GPQcelpStorageMode>(invalidType);

   517 	 //Should pass

   518 	err = aParse->GetQcelpStorageMode(invalidMode);

   519 	User::LeaveIfError(CheckError(err, KErrNone, _L("aParse->GetVideoProperties() invalid type")));

   520 

   521 	ParserCompleteL(aParse);

   522 	}

   523 

   524 // -----------------------------------------------------------------------------

   525 // Use invalid frame index for video frame APIs and Get video frame properties for more 

   526 // than the total number of video frames in the video clip

   527 // -----------------------------------------------------------------------------

   528 //

   529 C3GPLibParser_0108::C3GPLibParser_0108()

   530 	{	

   531 	}

   532 

   533 TVerdict C3GPLibParser_0108::doTestStepL()

   534 	{

   535 	if(TestStepResult() == EPass)

   536 		{

   537 		C3GPParse* parser = C3GPParse::NewL();

   538 		CleanupStack::PushL(parser);

   539 

   540 		TRAPD(err, AllInvalidFrameIndexL(parser));

   541 		if (err != KErrNone)

   542 			{

   543 			SetTestStepResult(EFail);

   544 			}

   545 		

   546 		CleanupStack::PopAndDestroy(parser);

   547 		}

   548 	return TestStepResult();

   549 	}

   550 

   551 void C3GPLibParser_0108::AllInvalidFrameIndexL(C3GPParse* aParse)

   552 	{

   553 	// file mode

   554 	ParserOpenFileL(aParse);

   555 	

   556 	TUint numOfVideoFrames;

   557 	TInt err = aParse->GetNumberOfVideoFrames(numOfVideoFrames);

   558 	User::LeaveIfError(CheckError(err, KErrNone, _L("aParse->GetNumberOfVideoFrames()")));

   559 	

   560 	// Invalid index. 

   561 	TUint size;

   562 	err = aParse->GetVideoFrameSize(numOfVideoFrames + 100, size);

   563 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameSize() invalid index")));

   564 	

   565 	err = aParse->GetVideoFrameSize((KMaxTUint-15), size);

   566 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameSize() negative index")));

   567 	

   568 	TUint timeStampInMs;

   569 	TUint timeStampInTimescale;

   570 	err = aParse->GetVideoFrameStartTime(numOfVideoFrames + 10, timeStampInMs, timeStampInTimescale);

   571 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameStartTime() invalid index")));

   572 	

   573 	err = aParse->GetVideoFrameStartTime((KMaxTUint-15), timeStampInMs, timeStampInTimescale);

   574 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameStartTime() negative index")));

   575 	

   576 	TBool keyFrame;

   577 	err = aParse->GetVideoFrameKeyType(numOfVideoFrames + 10, keyFrame);

   578 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameKeyType() invalid index")));

   579 	

   580 	err = aParse->GetVideoFrameKeyType((KMaxTUint-15), keyFrame);

   581 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameKeyType() negative index")));

   582 	

   583 	TUint numberOfFrames = 2;

   584 	RArray<T3GPFrameInfoParameters> array;

   585 	CleanupClosePushL(array);

   586 

   587 	err = aParse->GetVideoFrameProperties(numOfVideoFrames + 10, numberOfFrames, array);

   588 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameProperties() invalid index")));

   589 	

   590 	// Get video frame properties for more than the total number of video frames in the video clip

   591 	err = aParse->GetVideoFrameProperties(0, numOfVideoFrames + 10, array);

   592 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameProperties() invalid number of frame")));

   593 	

   594 	err = aParse->GetVideoFrameProperties((KMaxTUint-1), numOfVideoFrames, array);

   595 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameProperties() with negative index")));

   596 	

   597 	err = aParse->GetVideoFrameProperties(15, (KMaxTUint-10), array);

   598 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameProperties() with negative numOfVideoFrames")));

   599 

   600 	err = aParse->GetVideoFrameProperties((KMaxTUint-15), numOfVideoFrames + 10, array);

   601 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("aParse->GetVideoFrameProperties() with negative index and invalid numOfVideoFrames")));

   602 

   603 	CleanupStack::PopAndDestroy(&array);

   604 	

   605 	ParserCompleteL(aParse);

   606 	}

   607 

   608 // -----------------------------------------------------------------------------

   609 // Instantiate a 3GP Parser and Call all Parser API that uses frame type as 

   610 // input parameter with invalid frame types 

   611 // -----------------------------------------------------------------------------

   612 //

   613 C3GPLibParser_0109::C3GPLibParser_0109()

   614 	{	

   615 	}

   616 

   617 TVerdict C3GPLibParser_0109::doTestStepL()

   618 	{

   619 	if(TestStepResult() == EPass)

   620 		{

   621 		C3GPParse* parser = C3GPParse::NewL();

   622 		CleanupStack::PushL(parser);

   623 

   624 		TRAPD(err, InvalidFrameTypePanicL(parser));

   625 		if (err != KErrNone)

   626 			{

   627 			SetTestStepResult(EFail);

   628 			}

   629 		

   630 		CleanupStack::PopAndDestroy(parser);

   631 		}

   632 	return TestStepResult();

   633 	}

   634 

   635 void C3GPLibParser_0109::InvalidFrameTypePanicL(C3GPParse* aParse)

   636 	{

   637 	// file mode

   638 	ParserOpenFileL(aParse);

   639 	

   640 	TInt invalidType = 10;	

   641 	TBool available;

   642 	T3GPFrameType invalidFrameType = static_cast<T3GPFrameType>(invalidType);

   643 	 //Should panic

   644 	aParse->GetFrameAvailability(invalidFrameType, available);

   645 	

   646 	ParserCompleteL(aParse);

   647 	}

   648 

   649 // -----------------------------------------------------------------------------

   650 // Get user data atom by passing in an invalid user atom location.

   651 // -----------------------------------------------------------------------------

   652 //

   653 C3GPLibParser_0110::C3GPLibParser_0110()

   654 	{	

   655 	}

   656 

   657 TVerdict C3GPLibParser_0110::doTestStepL()

   658 	{

   659 	if(TestStepResult() == EPass)

   660 		{

   661 		C3GPParse* parser = C3GPParse::NewL();

   662 		CleanupStack::PushL(parser);

   663 

   664 		TRAPD(err, InvalidUdtLocationL(parser));

   665 		if (err != KErrNone)

   666 			{

   667 			SetTestStepResult(EFail);

   668 			}

   669 		

   670 		CleanupStack::PopAndDestroy(parser);

   671 		}

   672 	return TestStepResult();

   673 	}

   674 

   675 void C3GPLibParser_0110::InvalidUdtLocationL(C3GPParse* aParse)

   676 	{

   677 	// file mode

   678 	ParserOpenFileL(aParse);

   679 	

   680 	// Invalid type tests

   681 	TInt invalidType = 10;	

   682 	TUint index;

   683 	TUint32 udtType = 0x7469746c;

   684 	T3GPUdtaLocation invalidLocation = static_cast<T3GPUdtaLocation>(invalidType);	

   685 	RBuf8 buffer;

   686 	CleanupClosePushL(buffer);

   687 	buffer.CreateL(KBufferSize);	

   688 	 //Should panic

   689 	aParse->GetUserDataAtom(udtType, invalidLocation, buffer, index);

   690 	CleanupStack::PopAndDestroy(&buffer);

   691 	

   692 	ParserCompleteL(aParse);

   693 	}

   694 

   695 // -----------------------------------------------------------------------------

   696 // Retrieve information when that info is not in the file or the info is not

   697 // supported by the library

   698 // -----------------------------------------------------------------------------

   699 //

   700 C3GPLibParser_0111::C3GPLibParser_0111()

   701 	{	

   702 	}

   703 

   704 TVerdict C3GPLibParser_0111::doTestStepL()

   705 	{

   706 	if(TestStepResult() == EPass)

   707 		{

   708 		C3GPParse* parser = C3GPParse::NewL();

   709 		CleanupStack::PushL(parser);

   710 		

   711 		TRAPD(err, AllVideoAudioApiFailedL(parser));

   712 		if (err != KErrNone)

   713 			{

   714 			SetTestStepResult(EFail);

   715 			}

   716 		

   717 		CleanupStack::PopAndDestroy(parser);

   718 		}

   719 	return TestStepResult();

   720 	}

   721 

   722 void C3GPLibParser_0111::AllVideoAudioApiFailedL(C3GPParse* aParse)

   723 	{

   724 	// file mode

   725 	ParserOpenFileL(aParse);

   726 	

   727 	TInt expectedErr = KErrNone;

   728 	TUint32 udtType = 0x7469746c;

   729 	TUint index;

   730 	T3GPUdtaLocation location = E3GPUdtaVideoTrak;  

   731 	if (iTestSection.Compare(KAudioOnly) == 0 || iTestSection.Compare(KUnsupportedVideo) == 0)

   732 		{

   733 		CallVideoApiL(aParse, KErrNotSupported);

   734 		CallVideoDecoderInfoApiL(aParse, KErrNotSupported);

   735 		}

   736 	else if (iTestSection.Compare(KVideoOnly) == 0 || iTestSection.Compare(KUnsupportedAudioCodec) == 0 ||

   737 			iTestSection.Compare(KUnsupportedAudioStream) == 0)

   738 		{

   739 		CallAudioApiL(aParse, KErrNotSupported);

   740 		CallAudioDecoderInfoApiL(aParse, KErrNotSupported);

   741 		

   742 		location = E3GPUdtaAudioTrak;

   743 		}

   744 	else if (iTestSection.Compare(KWmaFile) == 0)

   745 		{

   746 		expectedErr = KErrCorrupt;

   747 		CallVideoDecoderInfoApiL(aParse, expectedErr);

   748 		CallUDTApiL(aParse, udtType, index, expectedErr, location); 

   749 		}

   750 	else if (iTestSection.Compare(KMisMatch) == 0)

   751 		{

   752 		// The test file doesn't contain MPEG-4 / AVC video stream. The decoder info should fail. 

   753 		CallVideoDecoderInfoApiL(aParse, KErrNotSupported);

   754 		CallUDTApiL(aParse, udtType, index, KErrNotFound, location); 

   755 		}

   756 	else if (iTestSection.Compare(KNoAudioNoVideo) == 0)

   757 		{

   758 		expectedErr = KErrNotSupported;

   759 		CallVideoApiL(aParse, expectedErr);

   760 		CallVideoDecoderInfoApiL(aParse, expectedErr);

   761 		CallAudioApiL(aParse, expectedErr);

   762 		CallAudioDecoderInfoApiL(aParse, expectedErr);

   763 		CallCommonApiL(aParse, KErrGeneral);

   764 		}

   765 	if (iTestSection.Compare(KWmaFile) == 0 || iTestSection.Compare(KMisMatch) == 0)

   766 		{

   767 		CallVideoApiL(aParse, expectedErr);

   768 		CallAudioApiL(aParse, expectedErr);

   769 		CallAudioDecoderInfoApiL(aParse, expectedErr);

   770 		CallCommonApiL(aParse, expectedErr);

   771 		}

   772 	else

   773 		{

   774 		CallUDTApiL(aParse, udtType, index, KErrNotFound, location); 

   775 		}

   776 	ParserCompleteL(aParse);

   777 	}

   778 

   779 // -----------------------------------------------------------------------------

   780 // Seek to an invalid position of the file.

   781 // -----------------------------------------------------------------------------

   782 //

   783 C3GPLibParser_0119::C3GPLibParser_0119()

   784 	{

   785 	}

   786 

   787 TVerdict C3GPLibParser_0119::doTestStepL()

   788 	{

   789 	if(TestStepResult() == EPass)

   790 		{

   791 		C3GPParse* parser = C3GPParse::NewL();

   792 		CleanupStack::PushL(parser);

   793 		

   794 		TRAPD(err, SeekTestL(parser));

   795 		if (err != KErrNone)

   796 			{

   797 			SetTestStepResult(EFail);

   798 			}

   799 		

   800 		CleanupStack::PopAndDestroy(parser);

   801 		}

   802 	return TestStepResult();

   803 	}

   804 

   805 void C3GPLibParser_0119::SeekTestL(C3GPParse* aParse)

   806 	{

   807 	// file mode

   808 	ParserOpenFileL(aParse);

   809 	

   810 	TUint audioPos;

   811 	TUint videoPos;

   812 	TUint timeStampInMs = 0;

   813 	

   814 	// Seek to position 0.

   815 	TInt err = KErrNone; 

   816 	err = aParse->Seek(timeStampInMs, ETrue, audioPos, videoPos);

   817 	if (iTestSection.Compare(KNoAudioNoVideo) == 0)

   818 		{

   819 		User::LeaveIfError(CheckError(err, KErrGeneral, 

   820 				_L("aParser->Seek(timeStampInMs, ETrue, audioPos, videoPos) with file without audio nor video")));

   821 		err = aParse->Seek(timeStampInMs, EFalse, audioPos, videoPos);

   822 		User::LeaveIfError(CheckError(err, KErrGeneral, 

   823 				_L("aParser->Seek(timeStampInMs, EFalse, audioPos, videoPos) with file without audio nor video")));

   824 		}	

   825 	else

   826 		{

   827 		User::LeaveIfError(CheckError(err, KErrNone, 

   828 				_L("aParser->Seek(timeStampInMs, ETrue, audioPos, videoPos) with file with audio/video")));

   829 		err = aParse->Seek(timeStampInMs, EFalse, audioPos, videoPos);

   830 		User::LeaveIfError(CheckError(err, KErrNone, 

   831 				_L("aParser->Seek(timeStampInMs, EFalse, audioPos, videoPos) with file with audio/video")));

   832 		}

   833 	

   834 	if (iTestSection.Compare(KNoAudioNoVideo) != 0)

   835 		{

   836 		// Retrieve video & audio stream length

   837 		TUint videoLength; 

   838 		TUint audioLength; 

   839 		TInt videoError;

   840 

   841 		err = GetClipProperties(aParse, videoError, videoLength, audioLength);

   842 		if (iTestSection.Compare(KAudioOnly) == 0)

   843 			{

   844 			// audio only, GetVideoProperties should fail with KErrNotSupported. Set video length to 0

   845 			User::LeaveIfError(CheckError(videoError, KErrNotSupported, _L("GetClipProperties(aParse, videoError, videoLength, audioLength))")));

   846 			videoLength = 0;

   847 			}

   848 		else if (iTestSection.Compare(KVideoOnly) == 0)

   849 			{

   850 			// video only, GetAudioProperties should fail with KErrNotSupported. Set audio length to 0

   851 			User::LeaveIfError(CheckError(err, KErrNotSupported, _L("GetClipProperties(aParse, videoError, videoLength, audioLength)")));

   852 			audioLength = 0;

   853 			}

   854 		else 

   855 			{

   856 			// All other files contains audio data

   857 			User::LeaveIfError(CheckError(videoError, KErrNone, _L("GetClipProperties(aParse, videoError, videoLength, audioLength)")));

   858 			User::LeaveIfError(CheckError(err, KErrNone, _L("GetClipProperties(aParse, videoError, videoLength, audioLength)")));

   859 			}

   860 		

   861 		if (audioLength >= videoLength)

   862 			{

   863 			timeStampInMs = audioLength + 10000;

   864 			}

   865 		else

   866 			{

   867 			timeStampInMs = videoLength + 10000;

   868 			}

   869 		

   870 		// Seek returns KErrNone even thought the position is more than the audio/video length. AudioPos/videoPos should

   871 		// be the the last audio/video position

   872 		err = aParse->Seek(timeStampInMs, EFalse, audioPos, videoPos);

   873 		User::LeaveIfError(CheckError(err, KErrNone, _L("aParser->Seek() to an invalid position")));

   874 		

   875 		timeStampInMs = 0;

   876 		err = aParse->Seek(timeStampInMs, EFalse, audioPos, videoPos);

   877 		User::LeaveIfError(CheckError(err, KErrNone, _L("aParser->Seek(0, EFalse, audioPos, videoPos)")));

   878 		}

   879 	ParserCompleteL(aParse);

   880 	}

   881 

   882 // -----------------------------------------------------------------------------

   883 // Read Video Decoder Info, video frame dependencies and user atom when these 

   884 // info is not in the file

   885 // -----------------------------------------------------------------------------

   886 //

   887 C3GPLibParser_0120::C3GPLibParser_0120()

   888 	{

   889 	}

   890 

   891 TVerdict C3GPLibParser_0120::doTestStepL()

   892 	{

   893 	if(TestStepResult() == EPass)

   894 		{

   895 		TInt readBufferSize = 1000;

   896 		C3GPParse* parser = C3GPParse::NewL(readBufferSize);

   897 		CleanupStack::PushL(parser);

   898 		

   899 		TRAPD(err, VideoAttributesL(parser));

   900 		if (err != KErrNone)

   901 			{

   902 			SetTestStepResult(EFail);

   903 			}

   904 		

   905 		CleanupStack::PopAndDestroy(parser);

   906 		}

   907 	return TestStepResult();

   908 	}

   909 

   910 void C3GPLibParser_0120::VideoAttributesL(C3GPParse* aParse)

   911 	{

   912 	// file mode

   913 	ParserOpenFileL(aParse);

   914 	

   915 	// Read Video Decoder Info from a mp4/3gp/3g2 file containing H263 video.

   916 	CallVideoDecoderInfoApiL(aParse, KErrNotSupported);

   917 	

   918 	ParserCompleteL(aParse);

   919 	}

   920 

   921 // -----------------------------------------------------------------------------

   922 // Instantiate parser with  read buffer size < 0. 

   923 // -----------------------------------------------------------------------------

   924 //

   925 C3GPLibParser_0126::C3GPLibParser_0126()

   926 	{	

   927 	}

   928 

   929 TVerdict C3GPLibParser_0126::doTestStepL()

   930 	{

   931 	if(TestStepResult() == EPass)

   932 		{

   933 		TInt readBufferSize = -1;

   934 		C3GPParse* parser = C3GPParse::NewL(readBufferSize);

   935 		if (parser)

   936 			{

   937 			SetTestStepResult(EFail);

   938 			delete parser;

   939 			parser = NULL;

   940 			}		

   941 		}

   942 	return TestStepResult();

   943 	}

   944 

   945 // -----------------------------------------------------------------------------

   946 // Retrieve video and audio info using empty buffer and size 1 buffer for all 

   947 // buffer related API.

   948 // -----------------------------------------------------------------------------

   949 //

   950 C3GPLibParser_0127::C3GPLibParser_0127()

   951 	{

   952 	}

   953 

   954 TVerdict C3GPLibParser_0127::doTestStepL()

   955 	{

   956 	if(TestStepResult() == EPass)

   957 		{

   958 		TInt readBufferSize = 1000;

   959 		C3GPParse* parser = C3GPParse::NewL(readBufferSize);

   960 		CleanupStack::PushL(parser);

   961 		

   962 		TRAPD(err, TestEmptyBufferL(parser));

   963 		if (err != KErrNone)

   964 			{

   965 			SetTestStepResult(EFail);

   966 			}

   967 		

   968 		CleanupStack::PopAndDestroy(parser);

   969 		}

   970 	return TestStepResult();

   971 	}

   972 

   973 void C3GPLibParser_0127::TestEmptyBufferL(C3GPParse* aParse)

   974 	{

   975 	// file mode

   976 	ParserOpenFileL(aParse);

   977 	

   978 	// Create an empty buffer

   979 	TInt expectedErr = KErrOverflow;

   980 	RBuf8 buffer;	

   981 	CleanupClosePushL(buffer);

   982 	

   983 	TUint32 udtType = 0x6d657461; // The udt type of test file is 'meta'

   984 	TUint index = 0;

   985 	T3GPUdtaLocation location = E3GPUdtaVideoTrak;

   986 	

   987 	if (iTestSection.Compare(KAudioMore) != 0)

   988 		{

   989 		buffer.CreateL(1);

   990 		}

   991 	else

   992 		{

   993 		buffer.CreateL(0);

   994 		}

   995 	

   996 	TInt err = aParse->GetUserDataAtom(udtType, location, buffer, index);

   997 	User::LeaveIfError(CheckError(err, expectedErr, _L("GetUserDataAtom")));

   998 	

   999 	err = aParse->GetVideoDecoderSpecificInfo(buffer);

  1000 	User::LeaveIfError(CheckError(err, expectedErr, _L("GetVideoDecoderSpecificInfo")));

  1001 	

  1002 	err = aParse->GetAudioDecoderSpecificInfo(buffer);

  1003 	User::LeaveIfError(CheckError(err, expectedErr, _L("GetAudioDecoderSpecificInfo")));

  1004 	

  1005 	err = aParse->InsertData(buffer);

  1006 	User::LeaveIfError(CheckError(err, KErrGeneral, _L("InsertData")));

  1007 	

  1008 	TUint timeStampInMs;

  1009 	TUint timeStampInTimescale;

  1010 	TInt returnedFrames;

  1011 	err = aParse->ReadAudioFrames(buffer, returnedFrames, timeStampInMs, timeStampInTimescale);

  1012 	User::LeaveIfError(CheckError(err, expectedErr, _L("ReadAudioFrames")));

  1013 	

  1014 	TBool keyframe;

  1015 	err = aParse->ReadVideoFrame(buffer, keyframe, timeStampInMs, timeStampInTimescale);

  1016 	User::LeaveIfError(CheckError(err, expectedErr, _L("ReadVideoFrame")));

  1017 	

  1018 	iSchedulerWait = new (ELeave) CActiveSchedulerWait;

  1019 	if(!iSchedulerWait)

  1020 		{

  1021 		User::Leave(KErrNoMemory);

  1022 		}

  1023 

  1024 	iWaitForNotification = ETrue;

  1025 	aParse->ReadVideoFrame(*this, buffer);

  1026 	

  1027 	if (iWaitForNotification)

  1028 	    {

  1029 		iSchedulerWait->Start();

  1030 	    }

  1031 	err = iAsyncError;

  1032 	User::LeaveIfError(CheckError(err, expectedErr, _L("ReadVideoFrame async")));

  1033 	

  1034 	iWaitForNotification = ETrue;

  1035 	aParse->ReadAudioFrames(*this, buffer);

  1036 	CleanupStack::PopAndDestroy(&buffer);

  1037 	

  1038 	if (iWaitForNotification)

  1039 	    {

  1040 		iSchedulerWait->Start();

  1041 	    }

  1042 	err = iAsyncError;

  1043 	User::LeaveIfError(CheckError(err, expectedErr, _L("ReadAudioFrames async")));

  1044 	

  1045 	if ( iSchedulerWait->IsStarted() )

  1046         {

  1047         iSchedulerWait->AsyncStop();

  1048 	    }

  1049 	ParserCompleteL(aParse);

  1050 	}

  1051 

  1052 // -----------------------------------------------------------------------------

  1053 // Async read before the parser has been setup.

  1054 // -----------------------------------------------------------------------------

  1055 //

  1056 C3GPLibParser_0130::C3GPLibParser_0130()

  1057 	{

  1058 	}

  1059 

  1060 TVerdict C3GPLibParser_0130::doTestStepPreambleL()

  1061 	{

  1062 	C3GPLib_AsyncObserver::doTestStepPreambleL();	

  1063 	if (TestStepResult() == EPass)

  1064 		{

  1065 		iScheduler = new (ELeave) CActiveScheduler;

  1066 		CActiveScheduler::Install(iScheduler);

  1067 		}

  1068 	return TestStepResult();

  1069 	}

  1070 

  1071 TVerdict C3GPLibParser_0130::doTestStepPostambleL()

  1072 	{

  1073 	C3GPLibParser_base::doTestStepPostambleL();

  1074 	if( iScheduler )

  1075 		{

  1076 		INFO_PRINTF1(_L("delete iScheduler"));

  1077 		CActiveScheduler::Install(NULL);

  1078 		delete iScheduler;

  1079 		iScheduler = NULL;

  1080 		}

  1081 

  1082 	return TestStepResult();

  1083 	}

  1084 

  1085 TVerdict C3GPLibParser_0130::doTestStepL()

  1086 	{

  1087 	if(TestStepResult() == EPass)

  1088 		{

  1089 		C3GPParse* parser = C3GPParse::NewL();

  1090 		CleanupStack::PushL(parser);

  1091 		

  1092 		TRAPD(err, ReadFrameAsyncWoOpenL(parser));

  1093 		if (err != KErrNone)

  1094 			{

  1095 			SetTestStepResult(EFail);

  1096 			}

  1097 		

  1098 		CleanupStack::PopAndDestroy(parser);

  1099 		}

  1100 	return TestStepResult();

  1101 	}

  1102 

  1103 void C3GPLibParser_0130::ReadFrameAsyncWoOpenL(C3GPParse* aParser)

  1104 	{

  1105 	TInt err = ReadAudioVideoFrameAsync(aParser, ETrue);

  1106 	User::LeaveIfError(CheckError(err, KErrNotReady, _L("ReadAudioVideoFrameAsync audio")));

  1107 

  1108 	err = ReadAudioVideoFrameAsync(aParser, EFalse);

  1109 	User::LeaveIfError(CheckError(err, KErrNotReady, _L("ReadAudioVideoFrameAsync video")));

  1110 	

  1111 	aParser->CancelReadFrame();

  1112 	}

  1113 

  1114 // -----------------------------------------------------------------------------

  1115 // Async read negative test after the parser has been setup.

  1116 // -----------------------------------------------------------------------------

  1117 //

  1118 C3GPLibParser_0131::C3GPLibParser_0131()

  1119 	{

  1120 	}

  1121 

  1122 TVerdict C3GPLibParser_0131::doTestStepPreambleL()

  1123 	{

  1124 	C3GPLib_AsyncObserver::doTestStepPreambleL();	

  1125 	if (TestStepResult() == EPass)

  1126 		{

  1127 		iScheduler = new (ELeave) CActiveScheduler;

  1128 		CActiveScheduler::Install(iScheduler);

  1129 		}

  1130 	return TestStepResult();

  1131 	}

  1132 

  1133 TVerdict C3GPLibParser_0131::doTestStepPostambleL()

  1134 	{

  1135 	C3GPLib_AsyncObserver::doTestStepPostambleL();