Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfunittest/ACOD/TSU_MMF

     1 // Copyright (c) 2002-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 //

    16 // EPOC includes

    17 #include <e32base.h>

    19 // Test system includes

    20 #include "TSU_MMF_ACOD.h"

    21 #include "TSU_MMF_ACODSuite.h"

    23 #include <f32file.h>

    24 #include <s32file.h>

    25 #include <mmf/plugin/mmfcodecimplementationuids.hrh>

    27 #ifdef __WINS__

    28 //wins directories

    29 _LIT(KSourceFilesDir, "c:\\mm\\mmf\\testfiles\\acod\\");

    30 _LIT(KComparisonFilesDir, "c:\\mm\\mmf\\ref\\acod\\");

    31 #else

    32 /*

    33 arm4 directories

    34 All source and comparison files need to be copied manually onto the flash card.

    35 This code assumes the flash card is represented by drive E: on the target board.

    36 If this is not the case, the KSourceFilesDir and KComparisonFilesDir strings

    37 need to be changed accordingly.

    38 */

    39 _LIT(KSourceFilesDir, "e:\\");

    40 _LIT(KComparisonFilesDir, "e:\\");

    41 #endif

    43 //8KHz source files

    44 _LIT(KPCM16SourceFile,"PCM16Source.raw");

    45 _LIT(KPCM16BSourceFile,"PCM16BSource.raw");

    46 _LIT(KPCMU16SourceFile,"PCMU16Source.raw");

    47 _LIT(KPCMU16BSourceFile,"PCMU16BSource.raw");

    48 _LIT(KStereoPCM16SourceFile,"StereoPCM16Source.raw");

    49 _LIT(KPCM8SourceFile,"PCM8Source.raw");

    50 _LIT(KPCMU8SourceFile,"PCMU8Source.raw");

    51 _LIT(KAlawSourceFile,"AlawSource.raw");

    52 _LIT(KMulawSourceFile,"MulawSource.raw");

    53 _LIT(KAdpcmSourceFile,"AdpcmSource.raw");

    54 _LIT(KStereoAdpcmSourceFile,"StereoAdpcmSource.raw");

    55 _LIT(KGSM610SourceFile,"GSM610Source.raw");

    57 //comparison files

    58 _LIT(KAlawToPCM16ComparisonFile,"AlawToPCM16Comparison.raw");

    59 _LIT(KPCM16ToAlawComparisonFile,"PCM16ToAlawComparison.raw");

    60 _LIT(KPCM8ToPCM16ComparisonFile,"PCM8ToPCM16Comparison.raw");

    61 _LIT(KPCM16ToPCM8ComparisonFile,"PCM16ToPCM8Comparison.raw");

    62 _LIT(KPCM16ToPCM16BComparisonFile,"PCM16ToPCM16BComparison.raw");

    63 _LIT(KPCM16BToPCM16ComparisonFile,"PCM16BToPCM16Comparison.raw");

    64 _LIT(KPCMU16ToPCMU16BComparisonFile,"PCMU16ToPCMU16BComparison.raw");

    65 _LIT(KPCMU16BToPCMU16ComparisonFile,"PCMU16BToPCMU16Comparison.raw");

    66 _LIT(KPCM16ToPCMU16BComparisonFile,"PCM16ToPCMU16BComparison.raw");

    67 _LIT(KPCMU16BToPCM16ComparisonFile,"PCMU16BToPCM16Comparison.raw");

    68 _LIT(KPCM16ToPCMU16ComparisonFile,"PCM16ToPCMU16Comparison.raw");

    69 _LIT(KPCMU16ToPCM16ComparisonFile,"PCMU16ToPCM16Comparison.raw");

    70 _LIT(KPCM16ToPCMU8ComparisonFile,"PCM16ToPCMU8Comparison.raw");

    71 _LIT(KPCMU8ToPCM16ComparisonFile,"PCMU8ToPCM16Comparison.raw");

    72 _LIT(KAdpcmToPCM16ComparisonFile,"AdpcmToPCM16Comparison.raw");

    73 _LIT(KPCM16ToAdpcmComparisonFile,"PCM16ToAdpcmComparison.raw");

    74 _LIT(KMulawToPCM16ComparisonFile,"MulawToPCM16Comparison.raw");

    75 _LIT(KPCM16ToMulawComparisonFile,"PCM16ToMulawComparison.raw");

    76 _LIT(KStereoAdpcmToPCM16ComparisonFile,"StereoAdpcmToPCM16Comparison.raw");

    77 _LIT(KPCM16ToStereoAdpcmComparisonFile,"PCM16ToStereoAdpcmComparison.raw");

    78 _LIT(KGSM610ToPCM16ComparisonFile,"GSM610ToPCM16Comparison.raw");

    79 _LIT(KPCM16ToGSM610ComparisonFile,"PCM16ToGSM610Comparison.raw");

    81 _LIT(KPreferredSupplierSourceFile,"AAAASource.raw");

    82 _LIT(KPreferredSupplierComparisonFile,"AAAABBBBPrefSuppComparison.raw");

    83 _LIT(KPreferredSupplier,"Preferred Supplier Test Codec 1");

    86 const TUint32 KMMFFourCCCodeAAAA = 0x41414141; //"AAAA"

    87 const TUint32 KMMFFourCCCodeBBBB = 0x42424242; //"BBBB"

    89 CTestStep_MMF_ACOD::CTestStep_MMF_ACOD()

    90 	{

    91 	iExpectedLeaveErrorCode = KErrNone;

    92 	iSingleIteration = EFalse;

    93 	}

    95 CTestStep_MMF_ACOD::~CTestStep_MMF_ACOD()

    96 	{

    97 	}

    99 /** @xxxx

   100  * This function gets the correct comparison filename for the codec specified.

   101  *

   102  * @param	"TInt aCodecUID"

   103  *			Uid of codec.

   104  *			"TDes& aFilename"

   105  *			Descriptor to contain the comparison filename string.

   106  */

   107 void CTestStep_MMF_ACOD::GetComparisonFilenameFromCodecUidL(TInt aCodecUID, TDes& aFilename)

   108 	{

   109 	switch(aCodecUID)

   110 		{

   111 		case KMmfUidCodecAlawToPCM16:

   112 			aFilename.Copy(KComparisonFilesDir);

   113 			aFilename.Append(KAlawToPCM16ComparisonFile);

   114 			break;

   115 		case KMmfUidCodecPCM16ToAlaw:

   116 			aFilename.Copy(KComparisonFilesDir);

   117 			aFilename.Append(KPCM16ToAlawComparisonFile);

   118 			break;

   119 		case KMmfUidCodecPCM8ToPCM16:

   120 			aFilename.Copy(KComparisonFilesDir);

   121 			aFilename.Append(KPCM8ToPCM16ComparisonFile);

   122 			break;

   123 		case KMmfUidCodecAudioS16ToPCMS8:

   124 			aFilename.Copy(KComparisonFilesDir);

   125 			aFilename.Append(KPCM16ToPCM8ComparisonFile);

   126 			break;

   127 		//case KMMFUidCodecPCM16SwapEndian:

   128 		case KMMFUidCodecPCM16toPCM16B:

   129 		case KMMFUidCodecPCM16BtoPCM16:

   130 		case KMMFUidCodecPCMU16toPCMU16B:

   131 		case KMMFUidCodecPCMU16BtoPCMU16:

   132 			//This file is used for all swap endian tests other than instantiation.

   133 			//There is no need to test ProcessL for every swap endian combination.

   134 			aFilename.Copy(KComparisonFilesDir);

   135 			aFilename.Append(KPCM16ToPCM16BComparisonFile);

   136 			break;

   137 		case KMmfUidCodecAudioS16ToPCMU16BE:

   138 			aFilename.Copy(KComparisonFilesDir);

   139 			aFilename.Append(KPCM16ToPCMU16BComparisonFile);

   140 			break;

   141 		case KMmfUidCodecAudioU16BEToPCMS16:

   142 			aFilename.Copy(KComparisonFilesDir);

   143 			aFilename.Append(KPCMU16BToPCM16ComparisonFile);

   144 			break;

   145 		case KMmfUidCodecAudioS16ToPCMU16:

   146 			aFilename.Copy(KComparisonFilesDir);

   147 			aFilename.Append(KPCM16ToPCMU16ComparisonFile);

   148 			break;

   149 		case KMmfUidCodecAudioU16ToPCMS16:

   150 			aFilename.Copy(KComparisonFilesDir);

   151 			aFilename.Append(KPCMU16ToPCM16ComparisonFile);

   152 			break;

   153 		case KMmfUidCodecAudioS16ToPCMU8:

   154 			aFilename.Copy(KComparisonFilesDir);

   155 			aFilename.Append(KPCM16ToPCMU8ComparisonFile);

   156 			break;

   157 		case KMmfUidCodecAudioU8ToPCMS16:

   158 			aFilename.Copy(KComparisonFilesDir);

   159 			aFilename.Append(KPCMU8ToPCM16ComparisonFile);

   160 			break;

   161 		case KMmfUidCodecIMAADPCMToPCM16:

   162 			aFilename.Copy(KComparisonFilesDir);

   163 			aFilename.Append(KAdpcmToPCM16ComparisonFile);

   164 			break;

   165 		case KMmfUidCodecPCM16ToIMAADPCM:

   166 			aFilename.Copy(KComparisonFilesDir);

   167 			aFilename.Append(KPCM16ToAdpcmComparisonFile);

   168 			break;

   169 		case KMmfUidCodecMulawToPCM16:

   170 			aFilename.Copy(KComparisonFilesDir);

   171 			aFilename.Append(KMulawToPCM16ComparisonFile);

   172 			break;

   173 		case KMmfUidCodecPCM16ToMulaw:

   174 			aFilename.Copy(KComparisonFilesDir);

   175 			aFilename.Append(KPCM16ToMulawComparisonFile);

   176 			break;

   177 		case KMmfUidCodecIMAADPCMToPCM16Stereo:

   178 			aFilename.Copy(KComparisonFilesDir);

   179 			aFilename.Append(KStereoAdpcmToPCM16ComparisonFile);

   180 			break;

   181 		case KMmfUidCodecPCM16ToIMAADPCMStereo:

   182 			aFilename.Copy(KComparisonFilesDir);

   183 			aFilename.Append(KPCM16ToStereoAdpcmComparisonFile);

   184 			break;

   185 		case KMmfUidCodecGSM610ToPCM16:

   186 			aFilename.Copy(KComparisonFilesDir);

   187 			aFilename.Append(KGSM610ToPCM16ComparisonFile);

   188 			break;

   189 		case KMmfUidCodecPCM16ToGSM610:

   190 			aFilename.Copy(KComparisonFilesDir);

   191 			aFilename.Append(KPCM16ToGSM610ComparisonFile);

   192 			break;

   193 		default:

   194 			User::Leave(KErrNotSupported);

   195 			break;

   196 		}

   197 	}

   199 /** @xxxx

   200  * This function gets the correct comparison filename for the fourCC codes specified.

   201  *

   202  * @param	"const TFourCC& aSrcFourCC"

   203  *			Source fourCC code.

   204  *			"const TFourCC& aDstFourCC"

   205  *			Destination fourCC code.

   206  *			"TDes& aFilename"

   207  *			Descriptor to contain the comparison filename string.

   208  */

   209 void CTestStep_MMF_ACOD::GetComparisonFilenameFromFourCCL(const TFourCC& aSrcFourCC, const TFourCC& aDstFourCC, TDes& aFilename)

   210 	{

   211 	if (aSrcFourCC == KMMFFourCCCodePCM16)

   212 		{

   213 		if (aDstFourCC == KMMFFourCCCodeALAW)

   214 			{

   215 			aFilename.Copy(KComparisonFilesDir);

   216 			aFilename.Append(KPCM16ToAlawComparisonFile);

   217 			}

   218 		else if (aDstFourCC == KMMFFourCCCodePCM16B)

   219 			{

   220 			aFilename.Copy(KComparisonFilesDir);

   221 			aFilename.Append(KPCM16ToPCM16BComparisonFile);

   222 			}

   223 		else if (aDstFourCC == KMMFFourCCCodePCM8)

   224 			{

   225 			aFilename.Copy(KComparisonFilesDir);

   226 			aFilename.Append(KPCM16ToPCM8ComparisonFile);

   227 			}

   228 		else if (aDstFourCC == KMMFFourCCCodePCMU16B)

   229 			{

   230 			aFilename.Copy(KComparisonFilesDir);

   231 			aFilename.Append(KPCM16ToPCMU16BComparisonFile);

   232 			}

   233 		else if (aDstFourCC == KMMFFourCCCodePCMU16)

   234 			{

   235 			aFilename.Copy(KComparisonFilesDir);

   236 			aFilename.Append(KPCM16ToPCMU16ComparisonFile);

   237 			}

   238 		else if (aDstFourCC == KMMFFourCCCodePCMU8)

   239 			{

   240 			aFilename.Copy(KComparisonFilesDir);

   241 			aFilename.Append(KPCM16ToPCMU8ComparisonFile);

   242 			}

   243 		else if (aDstFourCC == KMMFFourCCCodeIMAD)

   244 			{

   245 			aFilename.Copy(KComparisonFilesDir);

   246 			aFilename.Append(KPCM16ToAdpcmComparisonFile);

   247 			}

   248 		else if (aDstFourCC == KMMFFourCCCodeMuLAW)

   249 			{

   250 			aFilename.Copy(KComparisonFilesDir);

   251 			aFilename.Append(KPCM16ToMulawComparisonFile);

   252 			}

   253 		else if (aDstFourCC == KMMFFourCCCodeIMAS)

   254 			{

   255 			aFilename.Copy(KComparisonFilesDir);

   256 			aFilename.Append(KPCM16ToStereoAdpcmComparisonFile);

   257 			}

   258 		else if (aDstFourCC == KMMFFourCCCodeGSM610)

   259 			{

   260 			aFilename.Copy(KComparisonFilesDir);

   261 			aFilename.Append(KPCM16ToGSM610ComparisonFile);

   262 			}

   263 		}

   264 	else if (aDstFourCC == KMMFFourCCCodePCM16)

   265 		{

   266 		if (aSrcFourCC == KMMFFourCCCodeALAW)

   267 			{

   268 			aFilename.Copy(KComparisonFilesDir);

   269 			aFilename.Append(KAlawToPCM16ComparisonFile);

   270 			}

   271 		if (aSrcFourCC == KMMFFourCCCodePCM8)

   272 			{

   273 			aFilename.Copy(KComparisonFilesDir);

   274 			aFilename.Append(KPCM8ToPCM16ComparisonFile);

   275 			}

   276 		if (aSrcFourCC == KMMFFourCCCodePCM16B)

   277 			{

   278 			aFilename.Copy(KComparisonFilesDir);

   279 			aFilename.Append(KPCM16BToPCM16ComparisonFile);

   280 			}

   281 		if (aSrcFourCC == KMMFFourCCCodePCMU16B)

   282 			{

   283 			aFilename.Copy(KComparisonFilesDir);

   284 			aFilename.Append(KPCMU16BToPCM16ComparisonFile);

   285 			}

   286 		if (aSrcFourCC == KMMFFourCCCodePCMU16)

   287 			{

   288 			aFilename.Copy(KComparisonFilesDir);

   289 			aFilename.Append(KPCMU16ToPCM16ComparisonFile);

   290 			}

   291 		if (aSrcFourCC == KMMFFourCCCodePCMU8)

   292 			{

   293 			aFilename.Copy(KComparisonFilesDir);

   294 			aFilename.Append(KPCMU8ToPCM16ComparisonFile);

   295 			}

   296 		if (aSrcFourCC == KMMFFourCCCodeIMAD)

   297 			{

   298 			aFilename.Copy(KComparisonFilesDir);

   299 			aFilename.Append(KAdpcmToPCM16ComparisonFile);

   300 			}

   301 		if (aSrcFourCC == KMMFFourCCCodeMuLAW)

   302 			{

   303 			aFilename.Copy(KComparisonFilesDir);

   304 			aFilename.Append(KMulawToPCM16ComparisonFile);

   305 			}

   306 		if (aSrcFourCC == KMMFFourCCCodeIMAS)

   307 			{

   308 			aFilename.Copy(KComparisonFilesDir);

   309 			aFilename.Append(KStereoAdpcmToPCM16ComparisonFile);

   310 			}

   311 		if (aSrcFourCC == KMMFFourCCCodeGSM610)

   312 			{

   313 			aFilename.Copy(KComparisonFilesDir);

   314 			aFilename.Append(KGSM610ToPCM16ComparisonFile);

   315 			}

   316 		}

   317 	else if	((aSrcFourCC == KMMFFourCCCodePCMU16) &&

   318 			(aDstFourCC == KMMFFourCCCodePCMU16B))

   319 		{

   320 		aFilename.Copy(KComparisonFilesDir);

   321 		aFilename.Append(KPCMU16ToPCMU16BComparisonFile);

   322 		}

   323 	else if	((aSrcFourCC == KMMFFourCCCodePCMU16B) &&

   324 			(aDstFourCC == KMMFFourCCCodePCMU16))

   325 		{

   326 		aFilename.Copy(KComparisonFilesDir);

   327 		aFilename.Append(KPCMU16BToPCMU16ComparisonFile);

   328 		}

   329 	else

   330 		User::Leave(KErrNotSupported);

   331 	}

   333 /** @xxxx

   334  * This function gets the correct source filename for the codec specified.

   335  *

   336  * @param	"TInt aCodecUID"

   337  *			Uid of codec.

   338  *			"TDes& aFilename"

   339  *			Descriptor to contain the source filename string.

   340  */

   341 void CTestStep_MMF_ACOD::GetSourceFilenameFromCodecUidL(TInt aCodecUID, TDes& aFilename)

   342 	{

   343 	switch(aCodecUID)

   344 		{

   345 		case KMmfUidCodecAlawToPCM16:

   346 			aFilename.Copy(KSourceFilesDir);

   347 			aFilename.Append(KAlawSourceFile);

   348 			break;

   349 		case KMmfUidCodecPCM16ToAlaw:

   350 			aFilename.Copy(KSourceFilesDir);

   351 			aFilename.Append(KPCM16SourceFile);

   352 			break;

   353 		case KMmfUidCodecPCM8ToPCM16:

   354 			aFilename.Copy(KSourceFilesDir);

   355 			aFilename.Append(KPCM8SourceFile);

   356 			break;

   357 		case KMmfUidCodecAudioS16ToPCMS8:

   358 			aFilename.Copy(KSourceFilesDir);

   359 			aFilename.Append(KPCM16SourceFile);

   360 			break;

   361 		//case KMMFUidCodecPCM16SwapEndian:

   362 		case KMMFUidCodecPCM16toPCM16B:

   363 		case KMMFUidCodecPCM16BtoPCM16:

   364 		case KMMFUidCodecPCMU16toPCMU16B:

   365 		case KMMFUidCodecPCMU16BtoPCMU16:

   366 			//this file is used for all swap endian tests other than instantiation.

   367 			//there is no need to test ProcessL for every swap endian combination.

   368 			aFilename.Copy(KSourceFilesDir);

   369 			aFilename.Append(KPCM16SourceFile);

   370 			break;

   371 		case KMmfUidCodecAudioS16ToPCMU16BE:

   372 			aFilename.Copy(KSourceFilesDir);

   373 			aFilename.Append(KPCM16SourceFile);

   374 			break;

   375 		case KMmfUidCodecAudioU16BEToPCMS16:

   376 			aFilename.Copy(KSourceFilesDir);

   377 			aFilename.Append(KPCMU16BSourceFile);

   378 			break;

   379 		case KMmfUidCodecAudioS16ToPCMU16:

   380 			aFilename.Copy(KSourceFilesDir);

   381 			aFilename.Append(KPCM16SourceFile);

   382 			break;

   383 		case KMmfUidCodecAudioU16ToPCMS16:

   384 			aFilename.Copy(KSourceFilesDir);

   385 			aFilename.Append(KPCMU16SourceFile);

   386 			break;

   387 		case KMmfUidCodecAudioS16ToPCMU8:

   388 			aFilename.Copy(KSourceFilesDir);

   389 			aFilename.Append(KPCM16SourceFile);

   390 			break;

   391 		case KMmfUidCodecAudioU8ToPCMS16:

   392 			aFilename.Copy(KSourceFilesDir);

   393 			aFilename.Append(KPCMU8SourceFile);

   394 			break;

   395 		case KMmfUidCodecIMAADPCMToPCM16:

   396 			aFilename.Copy(KSourceFilesDir);

   397 			aFilename.Append(KAdpcmSourceFile);

   398 			break;

   399 		case KMmfUidCodecPCM16ToIMAADPCM:

   400 			aFilename.Copy(KSourceFilesDir);

   401 			aFilename.Append(KPCM16SourceFile);

   402 			break;

   403 		case KMmfUidCodecMulawToPCM16:

   404 			aFilename.Copy(KSourceFilesDir);

   405 			aFilename.Append(KMulawSourceFile);

   406 			break;

   407 		case KMmfUidCodecPCM16ToMulaw:

   408 			aFilename.Copy(KSourceFilesDir);

   409 			aFilename.Append(KPCM16SourceFile);

   410 			break;

   411 		case KMmfUidCodecIMAADPCMToPCM16Stereo:

   412 			aFilename.Copy(KSourceFilesDir);

   413 			aFilename.Append(KStereoAdpcmSourceFile);

   414 			break;

   415 		case KMmfUidCodecPCM16ToIMAADPCMStereo:

   416 			aFilename.Copy(KSourceFilesDir);

   417 			aFilename.Append(KStereoPCM16SourceFile);

   418 			break;

   419 		case KMmfUidCodecGSM610ToPCM16:

   420 			aFilename.Copy(KSourceFilesDir);

   421 			aFilename.Append(KGSM610SourceFile);

   422 			break;

   423 		case KMmfUidCodecPCM16ToGSM610:

   424 			aFilename.Copy(KSourceFilesDir);

   425 			aFilename.Append(KPCM16SourceFile);

   426 			break;

   427 		default:

   428 			User::Leave(KErrNotSupported);

   429 			break;

   430 		}

   431 	}

   433 /** @xxxx

   434  * This function gets the correct source filename for the fourCC codes specified.

   435  *

   436  * @param	"const TFourCC& aSrcFourCC"

   437  *			Source fourCC code.

   438  *			"const TFourCC& aDstFourCC"

   439  *			Destination fourCC code.

   440  *			"TDes& aFilename"

   441  *			Descriptor to contain the source filename string.

   442  */

   443 void CTestStep_MMF_ACOD::GetSourceFilenameFromFourCCL(const TFourCC& aSrcFourCC, const TFourCC& aDstFourCC, TDes& aFilename)

   444 	{

   445 	aFilename.Copy(KSourceFilesDir);

   446 	if (aSrcFourCC == KMMFFourCCCodePCM16)

   447 		{

   448 		if (aDstFourCC == KMMFFourCCCodeIMAS)

   449 			aFilename.Append(KStereoPCM16SourceFile);

   450 		else

   451 			aFilename.Append(KPCM16SourceFile);

   452 		}

   453 	else if (aSrcFourCC == KMMFFourCCCodeALAW)

   454 			aFilename.Append(KAlawSourceFile);

   455 	else if (aSrcFourCC == KMMFFourCCCodePCM8)

   456 			aFilename.Append(KPCM8SourceFile);

   457 	else if (aSrcFourCC == KMMFFourCCCodePCM16B)

   458 			aFilename.Append(KPCM16BSourceFile);

   459 	else if (aSrcFourCC == KMMFFourCCCodePCMU16B)

   460 			aFilename.Append(KPCMU16BSourceFile);

   461 	else if (aSrcFourCC == KMMFFourCCCodePCMU16)

   462 			aFilename.Append(KPCMU16SourceFile);

   463 	else if (aSrcFourCC == KMMFFourCCCodePCMU8)

   464 			aFilename.Append(KPCMU8SourceFile);

   465 	else if (aSrcFourCC == KMMFFourCCCodeIMAD)

   466 			aFilename.Append(KAdpcmSourceFile);

   467 	else if (aSrcFourCC == KMMFFourCCCodeMuLAW)

   468 			aFilename.Append(KMulawSourceFile);

   469 	else if (aSrcFourCC == KMMFFourCCCodeIMAS)

   470 			aFilename.Append(KStereoAdpcmSourceFile);

   471 	else if (aSrcFourCC == KMMFFourCCCodeGSM610)

   472 			aFilename.Append(KGSM610SourceFile);

   473 	else

   474 		User::Leave(KErrNotSupported);

   475 	}

   477 /** @xxxx

   478  * This function checks the data in iOutputDataBuffer against data in a comparison

   479  * file.

   480  *

   481  * @param	"const TDesC& aFilename"

   482  *			Full path of the comparison file to compare against.

   483  *			"TUint aPosition"

   484  *			File position from which to read the comparison data.

   485  * @return	"TBool"

   486  *			ETrue if the output is the same as the comparison data

   487  *			EFalse if the output is different to the comparison data

   488 */

   489 TBool CTestStep_MMF_ACOD::CheckOutputAgainstComparisonFileL(const TDesC& aFilename, TUint aPosition)

   490 	{

   491 	RFs fs;

   492 	User::LeaveIfError(fs.Connect());

   493 	CleanupClosePushL(fs);

   495 	RFile file;

   496 	User::LeaveIfError(file.Open(fs, aFilename, EFileRead|EFileShareAny));

   497 	CleanupClosePushL(file);

   499 	RFileReadStream fileReadStream(file, aPosition);

   500 	CleanupClosePushL(fileReadStream);

   502 	//read data from comparison file into descriptor

   503 	HBufC8* compBuffer = HBufC8::NewL(iOutputDataBuffer->Length());

   504 	CleanupStack::PushL(compBuffer);

   505 	TPtr8 compBufferPtr = compBuffer->Des();

   506 	TRAPD(err, fileReadStream.ReadL(compBufferPtr, iOutputDataBuffer->Length()));

   507 	if ((err != KErrNone) && (err != KErrEof)) User::LeaveIfError(err); //EOF not an error ?

   509 	//compare destination buffer with comparison descriptor

   510 	TInt result = iOutputDataBuffer->Compare(*compBuffer);

   512 	if (result != 0)

   513 		INFO_PRINTF3(_L(">> iOutputDataBuffer size is %d, Comparison buffer size is %d"), iOutputDataBuffer->Length(), compBuffer->Length());

   515 	CleanupStack::PopAndDestroy(4); //compBuffer, fileReadStream, file, fs

   517 	if (result == 0)

   518 		return ETrue;

   519 	else

   520 		return EFalse;

   521 	}

   523 /** @xxxx

   524  * This function checks the number of source bytes processed against

   525  * iExpectedSrcBytesProcessed.

   526  *

   527  * @param	"TUint aCount"

   528  *			Index in the iExpectedSrcBytesProcessed array to check the value against.

   529  * @return	"TBool"

   530  *			ETrue if the source bytes processed is as expected.

   531  *			EFalse if the source bytes processed is not as expected.

   532  */

   533 TBool CTestStep_MMF_ACOD::CheckSrcBytesProcessedL(TUint aCount)

   534 	{

   535 	if (iCodecProcessResult.iSrcBytesProcessed == iExpectedSrcBytesProcessed[aCount])

   536 		return ETrue;

   537 	else if (STATIC_CAST(TUint, iFileDataLeft) < iExpectedSrcBytesProcessed[aCount])

   538 		{

   539 		INFO_PRINTF4(_L(">> TCodecProcessResult::iSrcBytesProcessed is %d, Not enough source data available in file. iFileDataLeft for LOOP %d is %d"), iCodecProcessResult.iSrcBytesProcessed, aCount, iFileDataLeft);

   540 		if (iCodecProcessResult.iSrcBytesProcessed == STATIC_CAST(TUint, iFileDataLeft))

   541 			return ETrue;

   542 		else

   543 			return EFalse;

   544 		}

   545 	else

   546 		{

   547 		INFO_PRINTF4(_L(">> TCodecProcessResult::iSrcBytesProcessed is %d, iExpectedSrcBytesProcessed for LOOP %d is %d"), iCodecProcessResult.iSrcBytesProcessed, aCount, iExpectedSrcBytesProcessed[aCount]);

   548 		return EFalse;

   549 		}

   550 	}

   552 /** @xxxx

   553  * This function checks the number of destination bytes added against

   554  * iExpectedDstBytesAdded.

   555  *

   556  * @param	"TUint aCount"

   557  *			Index of the iExpectedDstBytesAdded array to check the value against.

   558  * @return	"TBool"

   559  *			ETrue if the dest bytes added is as expected.

   560  *			EFalse if the dest bytes added is not as expected.

   561  */

   562 TBool CTestStep_MMF_ACOD::CheckDstBytesAddedL(TUint aCount)

   563 	{

   564 	if (iCodecProcessResult.iDstBytesAdded == iExpectedDstBytesAdded[aCount])

   565 		return ETrue;

   566 	else if (STATIC_CAST(TUint, iFileDataLeft) < iExpectedSrcBytesProcessed[aCount])

   567 		{

   568 		INFO_PRINTF4(_L(">> TCodecProcessResult::iDstBytesAdded is %d, Not enough source data available in file. iFileDataLeft for LOOP %d is %d"), iCodecProcessResult.iDstBytesAdded, aCount, iFileDataLeft);

   569 		return ETrue;

   570 		}

   571 	else

   572 		{

   573 		INFO_PRINTF4(_L(">> TCodecProcessResult::iDstBytesAdded is %d, iExpectedDstBytesAdded for LOOP %d is %d"), iCodecProcessResult.iDstBytesAdded, aCount, iExpectedDstBytesAdded[aCount]);

   574 		return EFalse;

   575 		}

   576 	}

   578 /** @xxxx

   579  * This function checks the length of iOutputDataBuffer against iTotalDstBytesAdded.

   580  *

   581  * @return	"TBool"

   582  *			ETrue if the values are the same.

   583  *			EFalse if the values are different.

   584  */

   585 TBool CTestStep_MMF_ACOD::CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL()

   586 	{

   587 	if (iOutputDataBuffer->Length() == STATIC_CAST(TInt, iTotalDstBytesAdded))

   588 		return ETrue;

   589 	else

   590 		{

   591 		INFO_PRINTF3(_L(">> Output Data Buffer Length is %d, iTotalDstBytesAdded is %d"), iOutputDataBuffer->Length(), iTotalDstBytesAdded);

   592 		return EFalse;

   593 		}

   594 	}

   596 /** @xxxx

   597  * Checks the current return value against iExpectedReturnValue.

   598  *

   599  * @param	"TUint aCount"

   600  *			Index of the iExpectedReturnValue array to check the value against.

   601  * @return	"TBool"

   602  *			ETrue if the return value is as expected.

   603  *			EFalse if the return value is not as expected.

   604  */

   605 TBool CTestStep_MMF_ACOD::CheckReturnValueL(TUint aCount)

   606 	{

   607 	if (aCount >= 5)

   608 		User::Leave(KErrArgument);

   610 	if (iCodecProcessResult.iStatus == iExpectedReturnValue[aCount].iStatus)

   611 		{

   612 		return ETrue;

   613 		}

   614 	else

   615 		{

   616 		INFO_PRINTF4(_L(">> TCodecProcessResult::iStatus is %d, iExpectedReturnValue for LOOP %d is %d"), iCodecProcessResult.iStatus, aCount, iExpectedReturnValue[aCount].iStatus);

   617 		return EFalse;

   618 		}

   619 	}

   621 /** @xxxx

   622  * This function fills the source buffer with data from the file specified.

   623  *

   624  * @param	"CMMFBuffer* aSrcBuffer"

   625  *			Buffer to contain the data read from the source file.

   626  *			"const TDesC& aFileName"

   627  *			Name of source file to use.

   628  *			"TUint aPosition"

   629  *			Position in the file from which to read the data.

   630  */

   631 void CTestStep_MMF_ACOD::FillSourceBufferFromSourceFileL(CMMFBuffer* aSrcBuffer, const TDesC& aFilename, TUint aPosition)

   632 	{

   633 	RFs fs;

   634 	User::LeaveIfError(fs.Connect());

   635 	CleanupClosePushL(fs);

   637 	RFile file;

   638 	User::LeaveIfError(file.Open(fs, aFilename, EFileRead|EFileShareAny));

   639 	CleanupClosePushL(file);

   641 	iFileDataLeft = 0;

   642 	file.Size(iFileDataLeft);

   643 	if (STATIC_CAST(TInt, aPosition) < iFileDataLeft)

   644 		iFileDataLeft -= aPosition;

   645 	else User::Leave(KErrEof);

   647 	RFileReadStream fileReadStream(file, aPosition);

   648 	CleanupClosePushL(fileReadStream);

   650 	TInt srcBufferLength = STATIC_CAST(CMMFDataBuffer*, aSrcBuffer)->Data().MaxLength();

   652 	//read data from source file into source buffer

   653 	if(iFileDataLeft < srcBufferLength)

   654 		fileReadStream.ReadL(STATIC_CAST(CMMFDataBuffer*, aSrcBuffer)->Data(), iFileDataLeft);

   655 	else

   656 		fileReadStream.ReadL(STATIC_CAST(CMMFDataBuffer*, aSrcBuffer)->Data());

   658 	CleanupStack::PopAndDestroy(3);  //filereadstream, file, fs

   659 	}

   661 /** @xxxx

   662  * This function tests the functionality of ProcessL for the codec specified.

   663  *

   664  * @param	"TUid aCodecUID"

   665  *			Uid of the codec under test.

   666  *			"TUint aSrcBufferSize"

   667  *			Size of source buffer to test the codec with.

   668  *			"TUint aDstBufferSize"

   669  *			Size of destination buffer to test the codec with.

   670  *			"TUint aSrcBufferLength"

   671  *			Length of source buffer to test the codec with if less than the maxLength.

   672  *			aSrcBufferLength defaults to zero. It is not used unless a value is

   673  *			specified. A value should only be specified in cases where the buffer

   674  *			length is less than the maxlength.

   675  * @return	"TBool"

   676  *			ETrue if the test passes.

   677  *			EFalse if the test fails.

   678  */

   679 TBool CTestStep_MMF_ACOD::TestProcessL(TUid aCodecUID, TUint aSrcBufferSize, TUint aDstBufferSize, TUint aSrcBufferLength)

   680 	{

   681 	//create buffers

   682 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(aSrcBufferSize);

   683 	CleanupStack::PushL(srcBuffer);

   684 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(aDstBufferSize);

   685 	CleanupStack::PushL(dstBuffer);

   687 	//Fill source buffer with data

   688 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

   689 	TPtr ptrSrcFilename = srcFilename->Des();

   690 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

   691 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

   693 	//if source buffer has different length to max length, crop data

   694 	if (aSrcBufferLength > 0)

   695 		{

   696 		srcBuffer->Data().SetLength(aSrcBufferLength);

   697 		}

   699 	//instantiate codec

   700 	CMMFCodec* codec = CMMFCodec::NewL(aCodecUID);

   701 	CleanupStack::PushL(codec);

   703 	TBool testOK = ETrue;

   704 	TRAPD(err, iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer));

   705 	if (err)

   706 		{

   707 		ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessL Leave occurred in ProcessL, error code %d"), err);

   708 		testOK = EFalse;

   709 		}

   710 	else

   711 		{

   712 		//copy data to iOutputDataBuffer

   713 		iOutputDataBuffer = HBufC8::NewL(dstBuffer->Data().Length());

   714 		TPtr8 outputDataBufferPtr = iOutputDataBuffer->Des();

   715 		outputDataBufferPtr.Append(dstBuffer->Data());

   717 		iTotalDstBytesAdded = iCodecProcessResult.iDstBytesAdded;

   718 		iTotalSrcBytesProcessed = iCodecProcessResult.iSrcBytesProcessed;

   720 		//investigate results

   721 		HBufC* filename = HBufC::NewLC(KMaxPath);

   722 		TPtr ptrFilename = filename->Des();

   723 		GetComparisonFilenameFromCodecUidL(aCodecUID.iUid, ptrFilename);

   725 		if (!CheckOutputAgainstComparisonFileL(ptrFilename, 0))

   726 			{

   727 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckOutputAgainstComparisonFileL returned EFalse"));

   728 			testOK = EFalse;

   729 			}

   730 		if (!CheckDstBytesAddedL(0))

   731 			{

   732 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckDstBytesAddedL returned EFalse"));

   733 			testOK = EFalse;

   734 			}

   735 		if (!CheckSrcBytesProcessedL(0))

   736 			{

   737 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckSrcBytesProcessedL returned EFalse"));

   738 			testOK = EFalse;

   739 			}

   740 		if (!CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL())

   741 			{

   742 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL returned EFalse"));

   743 			testOK = EFalse;

   744 			}

   745 		if (!CheckReturnValueL(0))

   746 			{

   747 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessL CheckReturnValue returned EFalse"));

   748 			testOK = EFalse;

   749 			}

   751 		//clean up memory

   752 		CleanupStack::PopAndDestroy(); //filename

   753 		delete iOutputDataBuffer;

   754 		iOutputDataBuffer = NULL;

   755 		}

   757 	CleanupStack::PopAndDestroy(4); //codec, srcFilename, dstBuffer, srcBuffer

   759 	if(!testOK)

   760 		return EFalse;

   761 	else

   762 		return ETrue;

   763 	}

   766 /** @xxxx

   767  * This function tests the functionality of ProcessL for the codec specified.

   768  * It mimics the datapath by calling ProcessL five times in a loop, checking the

   769  * return value each time and passing in new buffers accordlingly.

   770  *

   771  * @param	"TUid aCodecUID"

   772  *			Uid of the codec under test.

   773  *			"TUint aSrcBufferSize"

   774  *			Size of source buffers to test the codec with.

   775  *			"TUint aDstBufferSize"

   776  *			Size of destination buffers to test the codec with.

   777  *			"TUint aSrcBufferLength"

   778  *			Length of source buffer to test the codec with if less than the maxLength.

   779  *			aSrcBufferLength defaults to zero and is not used unless a value is

   780  *			specified.A value should only be specified if the buffer length is less

   781  *			than the maxlength.

   782  *	 		"TBool aCheckExpectedBytesProcessed"

   783  *			Boolean value to determine whether to check the srcBytesProcessed and

   784  *			dstBytesAdded against their expected values. This defaults to true,

   785  *			but allows for the tests to be bypassed for non-linear codecs where the

   786  *			expected values are difficult to determine.

   787  * @return	"TBool"

   788  *			ETrue if the test passes.

   789  *			EFalse if the test fails.

   790  */

   791 TBool CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL(TUid aCodecUID, TUint aSrcBufferSize, TUint aDstBufferSize, TUint aSrcBufferLength, TBool aCheckExpectedBytesProcessed)

   792 	{

   793 	//create buffers

   794 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(aSrcBufferSize);

   795 	CleanupStack::PushL(srcBuffer);

   796 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(aDstBufferSize);

   797 	CleanupStack::PushL(dstBuffer);

   799 	//read first buffer of data

   800 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

   801 	TPtr ptrSrcFilename = srcFilename->Des();

   802 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

   803 	TRAPD(srcFileError, FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0));

   804 	TBool endOfFile = EFalse;

   805 	if (srcFileError == KErrEof)

   806 		endOfFile = ETrue;

   807 	else if (srcFileError)

   808 		User::Leave(srcFileError);

   811 	//if source buffer has different length to max length, crop data

   812 	if (aSrcBufferLength > 0)

   813 		{

   814 		srcBuffer->Data().SetLength(aSrcBufferLength);

   815 		}

   817 	//instantiate codec

   818 	CMMFCodec* codec = CMMFCodec::NewL(aCodecUID);

   819 	CleanupStack::PushL(codec);

   821 	TBool testOK = ETrue;

   822 	TRAPD(err, iOutputDataBuffer = HBufC8::NewL(aDstBufferSize*5));

   823 	User::LeaveIfError(err);

   824 	TPtr8 outputDataBufferPtr = iOutputDataBuffer->Des();

   827 	TUint maxIters = 0;

   828 	if(iSingleIteration)

   829 		{

   830 		maxIters = 1;

   831 		}

   832 	else

   833 		{

   834 		maxIters = 5;

   835 		}

   837 	for (TUint i=0; i</*5*/maxIters; i++)

   838 		{

   839 		TRAPD(err, iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer));

   840 		if (err)

   841 			{

   842 			if (err == iExpectedLeaveErrorCode)

   843 				break;

   844 			else

   845 				{

   846 				ERR_PRINTF3(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d Leave occurred in ProcessL, error code %d"), i, err);

   847 				testOK = EFalse;

   848 				break;

   849 				}

   850 			}

   851 		else if (iExpectedLeaveErrorCode)

   852 				{

   853 				ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d A leave was expected in ProcessL, but this didn't occur"), i);

   854 				testOK = EFalse;

   855 				break;

   856 				}

   858 		iTotalDstBytesAdded += iCodecProcessResult.iDstBytesAdded;

   859 		iTotalSrcBytesProcessed += iCodecProcessResult.iSrcBytesProcessed;

   861 		if (i<4)

   862 			{

   863 			switch (iCodecProcessResult.iStatus)

   864 				{

   865 				case TCodecProcessResult::EProcessComplete:

   866 					{

   867 					outputDataBufferPtr.Append(dstBuffer->Data());

   868 					dstBuffer->SetPosition(0);

   869 					if (!CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL())

   870 						{

   871 						ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL returned EFalse"), i);

   872 						testOK = EFalse;

   873 						}

   874 					srcBuffer->SetPosition(0);

   875 					srcBuffer->NextFrame();

   877 					if (!endOfFile)

   878 						{

   879 						TRAP(srcFileError, FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, iTotalSrcBytesProcessed));

   880 						if (srcFileError == KErrEof)

   881 							endOfFile = ETrue;

   882 						else if (srcFileError)

   883 							User::Leave(srcFileError);

   884 						}

   885 					if (aSrcBufferLength > 0)

   886 						srcBuffer->Data().SetLength(aSrcBufferLength);

   887 					break;

   888 					}

   889 				case TCodecProcessResult::EProcessIncomplete:

   890 					{

   891 					outputDataBufferPtr.Append(dstBuffer->Data());

   892 					dstBuffer->SetPosition(0);

   893 					if (!CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL())

   894 						{

   895 						ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL returned EFalse"), i);

   896 						testOK = EFalse;

   897 						}

   898 					srcBuffer->SetPosition(iCodecProcessResult.iSrcBytesProcessed + srcBuffer->Position());

   899 					break;

   900 					}

   901 				case TCodecProcessResult::EDstNotFilled:

   902 					{

   903 					dstBuffer->SetPosition(iCodecProcessResult.iDstBytesAdded + dstBuffer->Position());

   905 					if (!endOfFile)

   906 						{

   907 						TRAP(srcFileError, FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, iTotalSrcBytesProcessed));

   908 						if (srcFileError == KErrEof)

   909 							endOfFile = ETrue;

   910 						else if (srcFileError)

   911 							User::Leave(srcFileError);

   912 						}

   913 					if (aSrcBufferLength > 0)

   914 						srcBuffer->Data().SetLength(aSrcBufferLength);

   915 					break;

   916 					}

   917 				default:

   918 					User::Leave(KErrCorrupt); //should never get here

   919 				}

   920 			}

   921 		else //last time

   922 			{

   923 			outputDataBufferPtr.Append(dstBuffer->Data());

   924 			if (!CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL())

   925 				{

   926 				ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckOutputDataBufferSizeAgainstTotalDstBytesAddedL returned EFalse"), i);

   927 				testOK = EFalse;

   928 				}

   929 			}

   931 		if (!CheckReturnValueL(i))

   932 			{

   933 			ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckReturnValue returned EFalse"), i);

   934 			testOK = EFalse;

   935 			}

   936 		if (aCheckExpectedBytesProcessed)

   937 			{

   938 			if (!CheckDstBytesAddedL(i))

   939 				{

   940 				ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckDstBytesAddedL returned EFalse"), i);

   941 				testOK = EFalse;

   942 				}

   943 			if (!CheckSrcBytesProcessedL(i))

   944 				{

   945 				ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL LOOP %d CheckSrcBytesProcessedL returned EFalse"), i);

   946 				testOK = EFalse;

   947 				}

   948 			}

   950 		if (endOfFile)

   951 			break;

   952 		}

   954 	if (testOK)

   955 		{

   956 		HBufC* filename = HBufC::NewLC(KMaxPath);

   957 		TPtr ptrFilename = filename->Des();

   958 		GetComparisonFilenameFromCodecUidL(aCodecUID.iUid, ptrFilename);

   960 		if (!CheckOutputAgainstComparisonFileL(ptrFilename, 0))

   961 			{

   962 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestProcessLLoopFiveTimesL CheckOutputAgainstComparisonFileL returned EFalse"));

   963 			testOK = EFalse;

   964 			}

   966 		CleanupStack::PopAndDestroy(); //filename

   967 		}

   969 	//clean up memory

   970 	delete iOutputDataBuffer;

   971 	iOutputDataBuffer = NULL;

   972 	CleanupStack::PopAndDestroy(4); //codec, srcFilename, dstBuffer, srcBuffer

   974 	if(!testOK)

   975 		return EFalse;

   976 	else

   977 		return ETrue;

   978 	}

   980 /** @xxxx

   981  * This function tests how the codec handles a reposition. This test is only really

   982  * relevant to codecs that store data between calls to ProcessL. When a reposition

   983  * occurs the stored data should be flushed.

   984  *

   985  * ProcessL is called 3 times:

   986  * After the first call the frame number is increased by one;

   987  * After the second call the output data is checked to ensure that extra data HAS been

   988  *	written to the output buffer; The frame number is set to 5 to mimic a reposition.

   989  * After the third call the output data is checked to ensure that extra data HAS NOT

   990  *	been written to the output buffer.

   991  *

   992  * Note: It is important to use buffer sizes that will force the codec to store extra

   993  * data and return EProcessComplete or EDstNotFilled each time around the loop.

   994  *

   995  * @param	"TUid aCodecUID"

   996  *			Uid of the codec under test.

   997  *			"TUint aSrcBufferSize"

   998  *			Size of source buffer to test the codec with.

   999  *			"TUint aDstBufferSize"

  1000  *			Size of destination buffer to test the codec with.

  1001  * @return	"TBool"

  1002  *			ETrue if the test passes.

  1003  *			EFalse if the test fails.

  1004  */

  1005 TBool CTestStep_MMF_ACOD::TestRepositionL(TUid aCodecUID, TUint aSrcBufferSize, TUint aDstBufferSize)

  1006 	{

  1007 	//create buffers

  1008 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(aSrcBufferSize);

  1009 	CleanupStack::PushL(srcBuffer);

  1011 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(aDstBufferSize);

  1012 	CleanupStack::PushL(dstBuffer);

  1014 	//read first buffer of data

  1015 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

  1016 	TPtr ptrSrcFilename = srcFilename->Des();

  1017 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

  1018 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

  1020 	//instantiate codec

  1021 	CMMFCodec* codec = NULL;

  1022 	TRAPD(err, codec = CMMFCodec::NewL(aCodecUID));

  1023 	if (err)

  1024 		{

  1025 		ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestRepositionL Leave occurred in NewL, error code %d"), err);

  1026 		return EFalse;

  1027 		}

  1028 	else

  1029 		{

  1030 		CleanupStack::PushL(codec);

  1031 		}

  1033 	TBool testOK = ETrue;

  1034 	iOutputDataBuffer = HBufC8::NewL(aDstBufferSize);

  1035 	TPtr8 outputDataBufferPtr = iOutputDataBuffer->Des();

  1037 	HBufC* filename = HBufC::NewLC(KMaxPath);

  1038 	TPtr ptrFilename = filename->Des();

  1039 	GetComparisonFilenameFromCodecUidL(aCodecUID.iUid, ptrFilename);

  1041 	for (TUint i=0; i<3; i++)

  1042 		{

  1043 		iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer);

  1045 		if ((iCodecProcessResult.iStatus == TCodecProcessResult::EProcessComplete) ||

  1046 			(iCodecProcessResult.iStatus == TCodecProcessResult::EDstNotFilled))

  1047 			{

  1048 			switch(i)

  1049 				{

  1050 				case 0:

  1051 					{

  1052 					srcBuffer->SetPosition(0);

  1053 					srcBuffer->SetFrameNumber(5);

  1054 					dstBuffer->SetPosition(0);

  1056 					break;

  1057 					}

  1058 				case 1:

  1059 					{

  1060 					srcBuffer->SetPosition(0);

  1061 					srcBuffer->SetFrameNumber(0);

  1062 					dstBuffer->SetPosition(0);

  1064 					outputDataBufferPtr.Copy(dstBuffer->Data());

  1065 					if (CheckOutputAgainstComparisonFileL(ptrFilename, 0))

  1066 						{

  1067 						INFO_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestRepositionL CheckOutputAgainstComparisonFileL returned ETrue for LOOP %d."), i);

  1068 						INFO_PRINTF1(_L(">> If the codec stores left over data from the previous call to ProcessL, this may indicate that the test is invalid."));

  1069 						INFO_PRINTF1(_L(">> Try using different buffer sizes."));

  1070 						}

  1071 					break;

  1072 					}

  1073 				case 2:

  1074 					{

  1075 					outputDataBufferPtr.Copy(dstBuffer->Data());

  1076 					if (!CheckOutputAgainstComparisonFileL(ptrFilename, 0))

  1077 						{

  1078 						ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestRepositionL CheckOutputAgainstComparisonFileL returned EFalse for LOOP %d"), i);

  1079 						testOK = EFalse;

  1080 						}

  1081 					break;

  1082 					}

  1083 				default:

  1084 					break;

  1085 				}

  1086 			}

  1087 		else

  1088 			{

  1089 			INFO_PRINTF3(_L(">> CTestStep_MMF_ACOD::TestRepositionL Return code was %d for LOOP %d."), iCodecProcessResult.iStatus, i);

  1090 			INFO_PRINTF1(_L(">> This indicates that the test is invalid. Try using different buffer sizes."));

  1091 			break;

  1092 			}

  1093 		}

  1095 	//clean up memory

  1096 	delete iOutputDataBuffer;

  1097 	iOutputDataBuffer = NULL;

  1098 	CleanupStack::PopAndDestroy(5); //filename, codec, srcFilename, dstBuffer, srcBuffer

  1100 	if(!testOK)

  1101 		return EFalse;

  1102 	else

  1103 		return ETrue;

  1104 	}

  1106 /** @xxxx

  1107  * This function tests codec instantiation by Uid.

  1108  *

  1109  * @param	"TUid aCodecUID"

  1110  *			Uid of the codec under test.

  1111  * @return	"TBool"

  1112  *			ETrue if the test passes.

  1113  *			EFalse if the test fails.

  1114  */

  1115 TBool CTestStep_MMF_ACOD::TestNewL(TUid aCodecUID)

  1116 	{

  1117 	//create buffers

  1118 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1119 	CleanupStack::PushL(srcBuffer);

  1120 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1121 	CleanupStack::PushL(dstBuffer);

  1123 	//Fill source buffer with data

  1124 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

  1125 	TPtr ptrSrcFilename = srcFilename->Des();

  1126 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

  1127 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

  1129 	TBool testOK = ETrue;

  1130 	//create codec from uid

  1131 	CMMFCodec* codec = NULL;

  1132 	TRAPD(err, codec = CMMFCodec::NewL(aCodecUID));

  1133 	if (err)

  1134 		{

  1135 		ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestNewL Leave occurred in NewL, error code %d"), err);

  1136 		testOK = EFalse;

  1137 		}

  1138 	else

  1139 		{

  1140 		CleanupStack::PushL(codec);

  1142 		//Check codec is non-null

  1143 		if (!codec)

  1144 			{

  1145 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestNewL NewL returned NULL"));

  1146 			testOK = EFalse;

  1147 			}

  1148 		else

  1149 			{

  1150 			//Process one buffer of data

  1151 			iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer);

  1153 			//copy data to iOutputDataBuffer

  1154 			iOutputDataBuffer = HBufC8::NewL(dstBuffer->Data().Length());

  1155 			TPtr8 outputDataBufferPtr = iOutputDataBuffer->Des();

  1156 			outputDataBufferPtr.Append(dstBuffer->Data());

  1158 			//investigate results

  1159 			HBufC* filename = HBufC::NewLC(KMaxPath);

  1160 			TPtr ptrFilename = filename->Des();

  1161 			GetComparisonFilenameFromCodecUidL(aCodecUID.iUid, ptrFilename);

  1163 			if (!CheckOutputAgainstComparisonFileL(ptrFilename, 0))

  1164 				{

  1165 				ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestNewL CheckOutputAgainstComparisonFileL returned EFalse"));

  1166 				testOK = EFalse;

  1167 				}

  1168 			CleanupStack::PopAndDestroy(); //filename

  1169 			}

  1171 		CleanupStack::PopAndDestroy(); //codec

  1172 		delete iOutputDataBuffer;

  1173 		iOutputDataBuffer = NULL;

  1174 		}

  1176 	CleanupStack::PopAndDestroy(3); //srcFilename, dstBuffer, srcBuffer

  1178 	if(!testOK)

  1179 		return EFalse;

  1180 	else

  1181 		return ETrue;

  1182 	}

  1184 /** @xxxx

  1185  * This function tests codec instantiation by fourCC codes.

  1186  *

  1187  * @param	"const TFourCC& aSrcFourCC"

  1188  *			Source fourCC code of the codec under test.

  1189  *			"const TFourCC& aDstFourCC"

  1190  *			Destination fourCC code of the codec under test.

  1191  * @return	"TBool"

  1192  *			ETrue if the test passes.

  1193  *			EFalse if the test fails.

  1194  */

  1195 TBool CTestStep_MMF_ACOD::TestNewL(const TFourCC& aSrcFourCC, const TFourCC& aDstFourCC)

  1196 	{

  1197 	//create buffers

  1198 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1199 	CleanupStack::PushL(srcBuffer);

  1200 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1201 	CleanupStack::PushL(dstBuffer);

  1203 	//Fill source buffer with data

  1204 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

  1205 	TPtr ptrSrcFilename = srcFilename->Des();

  1206 	GetSourceFilenameFromFourCCL(aSrcFourCC, aDstFourCC, ptrSrcFilename);

  1207 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

  1209 	TBool testOK = ETrue;

  1211 	//create codec from uid

  1212 	CMMFCodec* codec = NULL;

  1213 	TRAPD(err, codec = CMMFCodec::NewL(aSrcFourCC, aDstFourCC));

  1214 	if (err)

  1215 		{

  1216 		ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestNewL Leave occurred in NewL, error code %d"), err);

  1217 		testOK = EFalse;

  1218 		}

  1219 	else

  1220 		{

  1221 		CleanupStack::PushL(codec);

  1223 		//Check codec is non-null

  1224 		if (!codec)

  1225 			{

  1226 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestNewL NULL CMMFCodec returned from NewL"));

  1227 			testOK = EFalse;

  1228 			}

  1229 		else

  1230 			{

  1231 			//Process one buffer of data

  1232 			iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer);

  1234 			//copy data to iOutputDataBuffer

  1235 			iOutputDataBuffer = HBufC8::NewL(dstBuffer->Data().Length());

  1236 			TPtr8 outputDataBufferPtr = iOutputDataBuffer->Des();

  1237 			outputDataBufferPtr.Append(dstBuffer->Data());

  1239 			//investigate results

  1240 			HBufC* filename = HBufC::NewLC(KMaxPath);

  1241 			TPtr ptrFilename = filename->Des();

  1242 			GetComparisonFilenameFromFourCCL(aSrcFourCC, aDstFourCC, ptrFilename);

  1244 			if (!CheckOutputAgainstComparisonFileL(ptrFilename, 0))

  1245 				{

  1246 				ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestNewL CheckOutputAgainstComparisonFileL returned EFalse"));

  1247 				testOK = EFalse;

  1248 				}

  1249 			CleanupStack::PopAndDestroy(); //filename

  1250 			}

  1252 		CleanupStack::PopAndDestroy(); //codec

  1253 		delete iOutputDataBuffer;

  1254 		iOutputDataBuffer = NULL;

  1255 		}

  1257 	CleanupStack::PopAndDestroy(3); //srcFilename, dstBuffer, srcBuffer

  1259 	if(!testOK)

  1260 		return EFalse;

  1261 	else

  1262 		return ETrue;

  1263 	}

  1265 /** @xxxx

  1266  * This function tests codec instantiation by fourCC codes and preferred supplier.

  1267  * Two new codecs have been created for the purpose of this test. They take the same

  1268  * fourCC codes (AAAA and BBBB) but have different suppliers.

  1269  *

  1270  * @return	"TBool"

  1271  *			ETrue if the test passes.

  1272  *			EFalse if the test fails.

  1273  */

  1274 TBool CTestStep_MMF_ACOD::TestNewLPreferredSupplierL()

  1275 	{

  1276 	//create buffers

  1277 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1278 	CleanupStack::PushL(srcBuffer);

  1279 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1280 	CleanupStack::PushL(dstBuffer);

  1282 	//Fill source buffer with data

  1283 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

  1284 	TPtr ptrSrcFilename = srcFilename->Des();

  1285 	ptrSrcFilename.Copy(KSourceFilesDir);

  1286 	ptrSrcFilename.Append(KPreferredSupplierSourceFile);

  1287 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

  1289 	TBool testOK = ETrue;

  1291 	//create codec from uid and preferredSupplier

  1292 	CMMFCodec* codec = NULL;

  1293 	TRAPD(err, codec = CMMFCodec::NewL(KMMFFourCCCodeAAAA, KMMFFourCCCodeBBBB, KPreferredSupplier));

  1294 	if (err)

  1295 		{

  1296 		ERR_PRINTF2(_L(">> CTestStep_MMF_ACOD::TestNewLPreferredSupplierL Leave occurred in NewL, error code %d"), err);

  1297 		testOK = EFalse;

  1298 		}

  1299 	else

  1300 		{

  1301 		CleanupStack::PushL(codec);

  1303 		//Check codec is non-null

  1304 		if (!codec)

  1305 			{

  1306 			ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestNewLPreferredSupplierL NULL CMMFCodec returned from NewL"));

  1307 			testOK = EFalse;

  1308 			}

  1309 		else

  1310 			{

  1311 			//Process one buffer of data

  1312 			iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer);

  1314 			//copy data to iOutputDataBuffer

  1315 			iOutputDataBuffer = HBufC8::NewL(dstBuffer->Data().Length());

  1316 			TPtr8 outputDataBufferPtr = iOutputDataBuffer->Des();

  1317 			outputDataBufferPtr.Append(dstBuffer->Data());

  1319 			//investigate results

  1320 			HBufC* filename = HBufC::NewLC(KMaxPath);

  1321 			TPtr ptrFilename = filename->Des();

  1322 			ptrFilename.Copy(KComparisonFilesDir);

  1323 			ptrFilename.Append(KPreferredSupplierComparisonFile);

  1325 			if (!CheckOutputAgainstComparisonFileL(ptrFilename, 0))

  1326 				{

  1327 				ERR_PRINTF1(_L(">> CTestStep_MMF_ACOD::TestNewLPreferredSupplierL CheckOutputAgainstComparisonFileL returned EFalse"));

  1328 				testOK = EFalse;

  1329 				}

  1331 			CleanupStack::PopAndDestroy(filename);

  1332 			}

  1334 		CleanupStack::PopAndDestroy(codec);

  1335 		delete iOutputDataBuffer;

  1336 		iOutputDataBuffer = NULL;

  1337 		}

  1339 	CleanupStack::PopAndDestroy(3, srcBuffer); //srcFilename, dstBuffer, srcBuffer

  1341 	if(!testOK)

  1342 		return EFalse;

  1343 	else

  1344 		return ETrue;

  1345 	}

  1347 /** @xxxx

  1348  * This functionality isn't implemented yet

  1349  */

  1350 TBool CTestStep_MMF_ACOD::TestMemoryScribbleL(TUid aCodecUID)

  1351 	{

  1352 	aCodecUID = aCodecUID;

  1354 	INFO_PRINTF1(_L(">> This test has not been implemented, as it has not yet been determined how to test for memory scribbles."));

  1355 	return ETrue;

  1356 	}

  1359 /** @xxxx

  1360  * This function panics if any memory leaks occur during the calls to NewL or ProcessL.

  1361  *

  1362  * @param	"TUid aCodecUID"

  1363  *			Uid of codec under test.

  1364  * @return	"TBool"

  1365  *			ETrue if the test passes.

  1366  *			EFalse if the test fails.

  1367  */

  1368 TBool CTestStep_MMF_ACOD::TestMemoryLeakL(TUid aCodecUID)

  1369 	{

  1370 	//create buffers

  1371 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1372 	CleanupStack::PushL(srcBuffer);

  1373 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1374 	CleanupStack::PushL(dstBuffer);

  1376 	//Fill source buffer with data

  1377 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

  1378 	TPtr ptrSrcFilename = srcFilename->Des();

  1379 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

  1380 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

  1382 	__MM_HEAP_MARK;

  1383 	//instantiate codec

  1384 	CMMFCodec* codec = CMMFCodec::NewL(aCodecUID);

  1385 	CleanupStack::PushL(codec);

  1387 	iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer);

  1389 	CleanupStack::PopAndDestroy(4); //codec, srcFilename, dstBuffer, srcBuffer

  1391 	__MM_HEAP_MARKEND;

  1393 	return ETrue;

  1394 	}

  1396 /** @xxxx

  1397  * This function tests how NewL deals with a memory allocation failure.

  1398  * This test will pass if NewL leaves with the correct error code on every

  1399  * memory allocation.

  1400  *

  1401  * @param	"TUid aCodecUID"

  1402  *			Uid of codec under test.

  1403  * @return	"TBool"

  1404  *			ETrue if the test passes.

  1405  *			EFalse if the test fails.

  1406  */

  1407 TBool CTestStep_MMF_ACOD::TestNewLOutOfMemoryL(TUid aCodecUID)

  1408 	{

  1409 	aCodecUID = aCodecUID;

  1410 	CMMFCodec* codec = NULL;

  1411 	TInt failCount = 1;

  1412 	TBool testComplete = EFalse;

  1413 	TBool testOK = ETrue;

  1415 	while (!testComplete)

  1416 		{

  1417 		TInt err = 0;

  1418 		__UHEAP_FAILNEXT(failCount);

  1419 		__MM_HEAP_MARK;

  1421 		TRAP(err, codec = CMMFCodec::NewL(aCodecUID));

  1423 		switch (err)

  1424 			{

  1425 			case KErrNoMemory :

  1426 				break;

  1427 			case KErrNone :

  1428 				{

  1429 				//attempt to allocate another cell. If this fails, we have tested all

  1430 				//of the memory allocs carried out by NewL.

  1431 				TAny *testAlloc = User::Alloc(1);

  1432 				if (testAlloc==NULL)

  1433 					{

  1434 					testComplete = ETrue;

  1435 					failCount --;

  1436 					}

  1437 				else

  1438 					User::Free(testAlloc);

  1440 				delete codec;

  1441 				codec = NULL;

  1442 				break;

  1443 				}

  1444 			default:

  1445 				{

  1446 				testOK = EFalse;

  1447 				testComplete = ETrue;

  1448 				break;

  1449 				}

  1450 			}

  1452 		__MM_HEAP_MARKEND;

  1453 		__UHEAP_RESET;

  1454 		failCount++;

  1455 		}

  1457 	if(!testOK)

  1458 		return EFalse;

  1459 	else

  1460 		return ETrue;

  1461 	}

  1464 /** @xxxx

  1465  * This function tests how ProcessL would deal with a memory allocation failure.

  1466  * For most of the codecs ProcessL doesn't allocate any memory, so this test will

  1467  * pass when ProcessL succeeds as well as when ProcessL leaves with the correct code.

  1468  *

  1469  * @param	"TUid aCodecUID"

  1470  *			Uid of codec under test.

  1471  * @return	"TBool"

  1472  *			ETrue if the test passes.

  1473  *			EFalse if the test fails.

  1474  */

  1475 TBool CTestStep_MMF_ACOD::TestProcessLOutOfMemoryL(TUid aCodecUID)

  1476 	{

  1477 	//create buffers

  1478 	CMMFDataBuffer *srcBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1479 	CleanupStack::PushL(srcBuffer);

  1480 	CMMFDataBuffer *dstBuffer = CMMFDataBuffer::NewL(KDefaultBufferSize);

  1481 	CleanupStack::PushL(dstBuffer);

  1483 	//Fill source buffer with data

  1484 	HBufC* srcFilename = HBufC::NewLC(KMaxPath);

  1485 	TPtr ptrSrcFilename = srcFilename->Des();

  1486 	GetSourceFilenameFromCodecUidL(aCodecUID.iUid, ptrSrcFilename);

  1487 	FillSourceBufferFromSourceFileL(srcBuffer, ptrSrcFilename, 0);

  1489 	//instantiate codec

  1490 	CMMFCodec* codec = CMMFCodec::NewL(aCodecUID);

  1491 	CleanupStack::PushL(codec);

  1492 	TBool testOK = ETrue;

  1493 	TUint failCount = 1;

  1494 	TBool testComplete = EFalse;

  1496 	while (!testComplete)

  1497 		{

  1498 		__UHEAP_FAILNEXT(failCount);

  1499 		__MM_HEAP_MARK;

  1500 		TRAPD(err, iCodecProcessResult = codec->ProcessL(*srcBuffer, *dstBuffer));

  1502 		switch (err)

  1503 			{

  1504 			case KErrNoMemory :

  1505 				break;

  1506 			case KErrNone :

  1507 				{

  1508 				//attempt to allocate another cell. If this fails, we have tested all

  1509 				//of the memory allocs carried out by ProcessL.

  1510 				TAny *testAlloc = User::Alloc(1);

  1511 				if (testAlloc==NULL)

  1512 					{

  1513 					testComplete = ETrue;

  1514 					failCount --;

  1515 					}

  1516 				else

  1517 					User::Free(testAlloc);

  1518 				break;

  1519 				}

  1520 			default:

  1521 				{

  1522 				testOK = EFalse;

  1523 				testComplete = ETrue;

  1524 				break;

  1525 				}

  1526 			}

  1528 		__MM_HEAP_MARKEND;

  1529 		__UHEAP_RESET;

  1530 		failCount++;

  1531 		}

  1533 	CleanupStack::PopAndDestroy(4); //codec, srcFilename, dstBuffer, srcBuffer

  1535 	if(!testOK)

  1536 		return EFalse;

  1537 	else

  1538 		return ETrue;

  1539 	}

  1541 //------------------------------------------------------------------

  1542 //			** TEST MMF_ACOD STEPS ***

  1544 //------------------------------------------------------------------

  1546 /** @xxxx

  1547  * Constructor

  1548  */

  1549 CTest_MMF_ACOD_U_0001::CTest_MMF_ACOD_U_0001()

  1550 	{

  1551 	// store the name of this test case

  1552 	// this is the name that is used by the script file

  1553 	// Each test step initialises it's own name

  1554 	iTestStepName = _L("MM-MMF-ACOD-U-0001-HP");

  1555 	}

  1557 /** @xxxx

  1558  * Instantiate a codec by FourCC Codes and preferred supplier

  1559  * @test Req. under test REQ172.6.3

  1560  */

  1561 TVerdict CTest_MMF_ACOD_U_0001::DoTestStepL()

  1562 	{

  1563 	TBool testOK = EFalse;

  1564 	TRAPD(err, testOK = TestNewLPreferredSupplierL());

  1566 	if (err)

  1567 		{

  1568 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1569 		return EFail;

  1570 		}

  1571 	else if (!testOK)

  1572 		{

  1573 		INFO_PRINTF1(_L("Test failed"));

  1574 		return EFail;

  1575 		}

  1576 	else

  1577 		return EPass;

  1578 	}

  1579 //------------------------------------------------------------------

  1581 /** @xxxx

  1582  * Constructor

  1583  */

  1584 CTest_MMF_ACOD_U_0002::CTest_MMF_ACOD_U_0002()

  1585 	{

  1586 	// store the name of this test case

  1587 	// this is the name that is used by the script file

  1588 	// Each test step initialises it's own name

  1589 	iTestStepName = _L("MM-MMF-ACOD-U-0002-HP");

  1590 	}

  1592 /** @xxxx

  1593  * ALAW To PCM16 Instantiate codec by FourCC Codes

  1594  * @test Req. under test REQ172.6.2, REQ172.11.1

  1595  */

  1596 TVerdict CTest_MMF_ACOD_U_0002::DoTestStepL()

  1597 	{

  1598 	TBool testOK = EFalse;

  1599 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodeALAW, KMMFFourCCCodePCM16));

  1601 	if (err)

  1602 		{

  1603 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1604 		return EFail;

  1605 		}

  1606 	else if (!testOK)

  1607 		{

  1608 		INFO_PRINTF1(_L("Test failed"));

  1609 		return EFail;

  1610 		}

  1611 	else

  1612 		return EPass;

  1613 	}

  1615 //------------------------------------------------------------------

  1617 /** @xxxx

  1618  * Constructor

  1619  */

  1620 CTest_MMF_ACOD_U_0003::CTest_MMF_ACOD_U_0003()

  1621 	{

  1622 	// store the name of this test case

  1623 	// this is the name that is used by the script file

  1624 	// Each test step initialises it's own name

  1625 	iTestStepName = _L("MM-MMF-ACOD-U-0003-HP");

  1626 	}

  1628 /** @xxxx

  1629  * ALAW To PCM16 Instantiate codec by UID

  1630  * @test Req. under test REQ172.6.1, REQ172.11.1

  1631  */

  1632 TVerdict CTest_MMF_ACOD_U_0003::DoTestStepL()

  1633 	{

  1634 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  1635 	TBool testOK = EFalse;

  1636 	TRAPD(err, testOK = TestNewL(codecUid));

  1638 	if (err)

  1639 		{

  1640 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1641 		return EFail;

  1642 		}

  1643 	else if (!testOK)

  1644 		{

  1645 		INFO_PRINTF1(_L("Test failed"));

  1646 		return EFail;

  1647 		}

  1648 	else

  1649 		return EPass;

  1650 	}

  1652 //------------------------------------------------------------------

  1654 /** @xxxx

  1655  * Constructor

  1656  */

  1657 CTest_MMF_ACOD_U_0004::CTest_MMF_ACOD_U_0004()

  1658 	{

  1659 	// store the name of this test case

  1660 	// this is the name that is used by the script file

  1661 	// Each test step initialises it's own name

  1662 	iTestStepName = _L("MM-MMF-ACOD-U-0004-HP");

  1664 	for (TUint i=0; i<5; i++)

  1665 		{

  1666 		iExpectedSrcBytesProcessed[i] = 50;

  1667 		iExpectedDstBytesAdded[i] = 100;

  1668 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  1669 		}

  1670 	}

  1672 /** @xxxx

  1673  * ALAW To PCM16 Pass in small source buffers

  1674  * @test Req. under test REQ172.6.4, REQ172.6.5

  1675  */

  1676 TVerdict CTest_MMF_ACOD_U_0004::DoTestStepL()

  1677 	{

  1678 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  1679 	TBool testOK = EFalse;

  1680 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KAlawToPCM16OptimumDst));

  1682 	if (err)

  1683 		{

  1684 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1685 		return EFail;

  1686 		}

  1687 	else if (!testOK)

  1688 		{

  1689 		INFO_PRINTF1(_L("Test failed"));

  1690 		return EFail;

  1691 		}

  1692 	else

  1693 		return EPass;

  1694 	}

  1696 //------------------------------------------------------------------

  1698 /** @xxxx

  1699  * Constructor

  1700  */

  1701 CTest_MMF_ACOD_U_0005::CTest_MMF_ACOD_U_0005()

  1702 	{

  1703 	// store the name of this test case

  1704 	// this is the name that is used by the script file

  1705 	// Each test step initialises it's own name

  1706 	iTestStepName = _L("MM-MMF-ACOD-U-0005-HP");

  1708 	for (TUint i=0; i<5; i++)

  1709 		{

  1710 		iExpectedSrcBytesProcessed[i] = 25;

  1711 		iExpectedDstBytesAdded[i] = 50;

  1712 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  1713 		}

  1714 	}

  1716 /** @xxxx

  1717  * ALAW To PCM16 Pass in small dest buffers

  1718  * @test Req. under test REQ172.6.4, REQ172.6.5

  1719  */

  1720 TVerdict CTest_MMF_ACOD_U_0005::DoTestStepL()

  1721 	{

  1722 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  1723 	TBool testOK = EFalse;

  1724 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KAlawToPCM16OptimumSrc, KSmallBufferSize));

  1726 	if (err)

  1727 		{

  1728 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1729 		return EFail;

  1730 		}

  1731 	else if (!testOK)

  1732 		{

  1733 		INFO_PRINTF1(_L("Test failed"));

  1734 		return EFail;

  1735 		}

  1736 	else

  1737 		return EPass;

  1738 	}

  1740 //------------------------------------------------------------------

  1742 /** @xxxx

  1743  * Constructor

  1744  */

  1745 CTest_MMF_ACOD_U_0006::CTest_MMF_ACOD_U_0006()

  1746 	{

  1747 	// store the name of this test case

  1748 	// this is the name that is used by the script file

  1749 	// Each test step initialises it's own name

  1750 	iTestStepName = _L("MM-MMF-ACOD-U-0006-HP");

  1751 	iHeapSize = 0x20000;

  1753 	for (TUint i=0; i<5; i++)

  1754 		{

  1755 		iExpectedSrcBytesProcessed[i] = 5000;

  1756 		iExpectedDstBytesAdded[i] = 10000;

  1758 		if((i%2)==0)//even i

  1759 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  1760 		else		//odd i

  1761 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  1762 		}

  1763 	}

  1765 /** @xxxx

  1766  * ALAW To PCM16 Pass in large buffers

  1767  * @test Req. under test REQ172.6.4, REQ172.6.5

  1768  */

  1769 TVerdict CTest_MMF_ACOD_U_0006::DoTestStepL()

  1770 	{

  1771 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  1772 	TBool testOK = EFalse;

  1773 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  1775 	if (err)

  1776 		{

  1777 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1778 		return EFail;

  1779 		}

  1780 	else if (!testOK)

  1781 		{

  1782 		INFO_PRINTF1(_L("Test failed"));

  1783 		return EFail;

  1784 		}

  1785 	else

  1786 		return EPass;

  1787 	}

  1789 //------------------------------------------------------------------

  1791 /** @xxxx

  1792  * Constructor

  1793  */

  1794 CTest_MMF_ACOD_U_0007::CTest_MMF_ACOD_U_0007()

  1795 	{

  1796 	// store the name of this test case

  1797 	// this is the name that is used by the script file

  1798 	// Each test step initialises it's own name

  1799 	iTestStepName = _L("MM-MMF-ACOD-U-0007-HP");

  1801 	for (TUint i=0; i<5; i++)

  1802 		{

  1803 		iExpectedSrcBytesProcessed[i] = 0x800;

  1804 		iExpectedDstBytesAdded[i] = 0x1000;

  1806 		if((i%2)==0)//even i

  1807 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  1808 		else		//odd i

  1809 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  1810 		}

  1811 	}

  1813 /** @xxxx

  1814  * ALAW To PCM16 Pass in default sized buffers

  1815  * @test Req. under test REQ172.6.4, REQ172.6.5

  1816  */

  1817 TVerdict CTest_MMF_ACOD_U_0007::DoTestStepL()

  1818 	{

  1819 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  1820 	TBool testOK = EFalse;

  1821 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  1823 	if (err)

  1824 		{

  1825 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1826 		return EFail;

  1827 		}

  1828 	else if (!testOK)

  1829 		{

  1830 		INFO_PRINTF1(_L("Test failed"));

  1831 		return EFail;

  1832 		}

  1833 	else

  1834 		return EPass;

  1835 	}

  1837 //------------------------------------------------------------------

  1839 /** @xxxx

  1840  * Constructor

  1841  */

  1842 CTest_MMF_ACOD_U_0008::CTest_MMF_ACOD_U_0008()

  1843 	{

  1844 	// store the name of this test case

  1845 	// this is the name that is used by the script file

  1846 	// Each test step initialises it's own name

  1847 	iTestStepName = _L("MM-MMF-ACOD-U-0008-HP");

  1849 	for (TUint i=0; i<5; i++)

  1850 		{

  1851 		iExpectedSrcBytesProcessed[i] = 0x800;

  1852 		iExpectedDstBytesAdded[i] = 0x1000;

  1854 		if((i%2)==0)//even i

  1855 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  1856 		else		//odd i

  1857 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  1858 		}

  1859 	}

  1861 /** @xxxx

  1862  * ALAW To PCM16 Pass in buffers with different max length and length

  1863  * @test Req. under test REQ172.6.4, REQ172.6.5

  1864  */

  1865 TVerdict CTest_MMF_ACOD_U_0008::DoTestStepL()

  1866 	{

  1867 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  1868 	TBool testOK = EFalse;

  1869 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  1871 	if (err)

  1872 		{

  1873 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1874 		return EFail;

  1875 		}

  1876 	else if (!testOK)

  1877 		{

  1878 		INFO_PRINTF1(_L("Test failed"));

  1879 		return EFail;

  1880 		}

  1881 	else

  1882 		return EPass;

  1883 	}

  1885 //------------------------------------------------------------------

  1887 /** @xxxx

  1888  * Constructor

  1889  */

  1890 CTest_MMF_ACOD_U_0009::CTest_MMF_ACOD_U_0009()

  1891 	{

  1892 	// store the name of this test case

  1893 	// this is the name that is used by the script file

  1894 	// Each test step initialises it's own name

  1895 	iTestStepName = _L("MM-MMF-ACOD-U-0009-HP");

  1897 	for (TUint i=0; i<5; i++)

  1898 		{

  1899 		iExpectedSrcBytesProcessed[i] = 0x800;

  1900 		iExpectedDstBytesAdded[i] = 0x1000;

  1901 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  1902 		}

  1903 	}

  1905 /** @xxxx

  1906  * ALAW To PCM16 Pass in buffers of optimum size

  1907  * @test Req. under test REQ172.6.4, REQ172.6.5

  1908  */

  1909 TVerdict CTest_MMF_ACOD_U_0009::DoTestStepL()

  1910 	{

  1911 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  1912 	TBool testOK = EFalse;

  1913 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KAlawToPCM16OptimumSrc, KAlawToPCM16OptimumDst));

  1915 	if (err)

  1916 		{

  1917 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1918 		return EFail;

  1919 		}

  1920 	else if (!testOK)

  1921 		{

  1922 		INFO_PRINTF1(_L("Test failed"));

  1923 		return EFail;

  1924 		}

  1925 	else

  1926 		return EPass;

  1927 	}

  1929 //------------------------------------------------------------------

  1931 /** @xxxx

  1932  * Constructor

  1933  */

  1934 CTest_MMF_ACOD_U_0010::CTest_MMF_ACOD_U_0010()

  1935 	{

  1936 	// store the name of this test case

  1937 	// this is the name that is used by the script file

  1938 	// Each test step initialises it's own name

  1939 	iTestStepName = _L("MM-MMF-ACOD-U-0010-HP");

  1940 //	iHeapSize = 0x20000;

  1941 	}

  1943 /** @xxxx

  1944  * ALAW To PCM16 Reposition source pointer during conversion

  1945  * @test Req. under test REQ172.11

  1946  */

  1947 TVerdict CTest_MMF_ACOD_U_0010::DoTestStepL()

  1948 	{

  1949 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  1950 	TBool testOK = EFalse;

  1951 	INFO_PRINTF1(_L(">> The ALAW to PCM16 codec doesn't currently store data between calls to ProcessL"));

  1953 	TRAPD(err, testOK = TestRepositionL(codecUid, KAlawToPCM16OptimumSrc, KAlawToPCM16OptimumDst+30));

  1955 	if (err)

  1956 		{

  1957 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1958 		return EFail;

  1959 		}

  1960 	else if (!testOK)

  1961 		{

  1962 		INFO_PRINTF1(_L("Test failed"));

  1963 		return EFail;

  1964 		}

  1965 	else

  1966 		return EPass;

  1967 	}

  1969 //------------------------------------------------------------------

  1971 /** @xxxx

  1972  * Constructor

  1973  */

  1974 CTest_MMF_ACOD_U_0011::CTest_MMF_ACOD_U_0011()

  1975 	{

  1976 	// store the name of this test case

  1977 	// this is the name that is used by the script file

  1978 	// Each test step initialises it's own name

  1979 	iTestStepName = _L("MM-MMF-ACOD-U-0011-HP");

  1980 	}

  1982 /** @xxxx

  1983  * PCM16 To ALAW Instantiate codec by FourCC Codes

  1984  * @test Req. under test REQ172.6.2, REQ172.11.3

  1985  */

  1986 TVerdict CTest_MMF_ACOD_U_0011::DoTestStepL()

  1987 	{

  1988 	TBool testOK = EFalse;

  1989 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodeALAW));

  1991 	if (err)

  1992 		{

  1993 		INFO_PRINTF2(_L("Test left with status %d"), err);

  1994 		return EFail;

  1995 		}

  1996 	else if (!testOK)

  1997 		{

  1998 		INFO_PRINTF1(_L("Test failed"));

  1999 		return EFail;

  2000 		}

  2001 	else

  2002 		return EPass;

  2003 	}

  2005 //------------------------------------------------------------------

  2007 /** @xxxx

  2008  * Constructor

  2009  */

  2010 CTest_MMF_ACOD_U_0012::CTest_MMF_ACOD_U_0012()

  2011 	{

  2012 	// store the name of this test case

  2013 	// this is the name that is used by the script file

  2014 	// Each test step initialises it's own name

  2015 	iTestStepName = _L("MM-MMF-ACOD-U-0012-HP");

  2016 	}

  2018 /** @xxxx

  2019  * PCM16 To ALAW Instantiate codec by UID

  2020  * @test Req. under test REQ172.6.1, REQ172.11.3

  2021  */

  2022 TVerdict CTest_MMF_ACOD_U_0012::DoTestStepL()

  2023 	{

  2024 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  2025 	TBool testOK = EFalse;

  2026 	TRAPD(err, testOK = TestNewL(codecUid));

  2028 	if (err)

  2029 		{

  2030 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2031 		return EFail;

  2032 		}

  2033 	else if (!testOK)

  2034 		{

  2035 		INFO_PRINTF1(_L("Test failed"));

  2036 		return EFail;

  2037 		}

  2038 	else

  2039 		return EPass;

  2040 	}

  2042 //------------------------------------------------------------------

  2044 /** @xxxx

  2045  * Constructor

  2046  */

  2047 CTest_MMF_ACOD_U_0013::CTest_MMF_ACOD_U_0013()

  2048 	{

  2049 	// store the name of this test case

  2050 	// this is the name that is used by the script file

  2051 	// Each test step initialises it's own name

  2052 	iTestStepName = _L("MM-MMF-ACOD-U-0013-HP");

  2054 	for (TUint i=0; i<5; i++)

  2055 		{

  2056 		iExpectedSrcBytesProcessed[i] = 50;

  2057 		iExpectedDstBytesAdded[i] = 25;

  2058 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  2059 		}

  2060 	}

  2062 /** @xxxx

  2063  * PCM16 To ALAW Pass in small source buffers

  2064  * @test Req. under test REQ172.6.4, REQ172.6.5

  2065  */

  2066 TVerdict CTest_MMF_ACOD_U_0013::DoTestStepL()

  2067 	{

  2068 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  2069 	TBool testOK = EFalse;

  2070 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM16ToAlawOptimumDst));

  2072 	if (err)

  2073 		{

  2074 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2075 		return EFail;

  2076 		}

  2077 	else if (!testOK)

  2078 		{

  2079 		INFO_PRINTF1(_L("Test failed"));

  2080 		return EFail;

  2081 		}

  2082 	else

  2083 		return EPass;

  2084 	}

  2086 //------------------------------------------------------------------

  2088 /** @xxxx

  2089  * Constructor

  2090  */

  2091 CTest_MMF_ACOD_U_0014::CTest_MMF_ACOD_U_0014()

  2092 	{

  2093 	// store the name of this test case

  2094 	// this is the name that is used by the script file

  2095 	// Each test step initialises it's own name

  2096 	iTestStepName = _L("MM-MMF-ACOD-U-0014-HP");

  2098 	for (TUint i=0; i<5; i++)

  2099 		{

  2100 		iExpectedSrcBytesProcessed[i] = 100;

  2101 		iExpectedDstBytesAdded[i] = 50;

  2102 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  2103 		}

  2104 	}

  2106 /** @xxxx

  2107  * PCM16 To ALAW Pass in small dest buffers

  2108  * @test Req. under test REQ172.6.4, REQ172.6.5

  2109  */

  2110 TVerdict CTest_MMF_ACOD_U_0014::DoTestStepL()

  2111 	{

  2112 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  2113 	TBool testOK = EFalse;

  2114 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToAlawOptimumSrc, KSmallBufferSize));

  2116 	if (err)

  2117 		{

  2118 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2119 		return EFail;

  2120 		}

  2121 	else if (!testOK)

  2122 		{

  2123 		INFO_PRINTF1(_L("Test failed"));

  2124 		return EFail;

  2125 		}

  2126 	else

  2127 		return EPass;

  2128 	}

  2130 //------------------------------------------------------------------

  2132 /** @xxxx

  2133  * Constructor

  2134  */

  2135 CTest_MMF_ACOD_U_0015::CTest_MMF_ACOD_U_0015()

  2136 	{

  2137 	// store the name of this test case

  2138 	// this is the name that is used by the script file

  2139 	// Each test step initialises it's own name

  2140 	iTestStepName = _L("MM-MMF-ACOD-U-0015-HP");

  2141 	iHeapSize = 0x20000;

  2143 	for (TUint i=0; i<5; i++)

  2144 		{

  2145 		iExpectedSrcBytesProcessed[i] = 10000;

  2146 		iExpectedDstBytesAdded[i] = 5000;

  2148 		if((i%2)==0)//even i

  2149 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  2150 		else		//odd i

  2151 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2152 		}

  2153 	}

  2155 /** @xxxx

  2156  * PCM16 To ALAW Pass in large buffers

  2157  * @test Req. under test REQ172.6.4, REQ172.6.5

  2158  */

  2159 TVerdict CTest_MMF_ACOD_U_0015::DoTestStepL()

  2160 	{

  2161 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  2162 	TBool testOK = EFalse;

  2163 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  2165 	if (err)

  2166 		{

  2167 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2168 		return EFail;

  2169 		}

  2170 	else if (!testOK)

  2171 		{

  2172 		INFO_PRINTF1(_L("Test failed"));

  2173 		return EFail;

  2174 		}

  2175 	else

  2176 		return EPass;

  2177 	}

  2179 //------------------------------------------------------------------

  2181 /** @xxxx

  2182  * Constructor

  2183  */

  2184 CTest_MMF_ACOD_U_0016::CTest_MMF_ACOD_U_0016()

  2185 	{

  2186 	// store the name of this test case

  2187 	// this is the name that is used by the script file

  2188 	// Each test step initialises it's own name

  2189 	iTestStepName = _L("MM-MMF-ACOD-U-0016-HP");

  2191 	for (TUint i=0; i<5; i++)

  2192 		{

  2193 		iExpectedSrcBytesProcessed[i] = 0x1000;

  2194 		iExpectedDstBytesAdded[i] = 0x800;

  2196 		if((i%2)==0)//even i

  2197 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  2198 		else		//odd i

  2199 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2200 		}

  2201 	}

  2203 /** @xxxx

  2204  * PCM16 To ALAW Pass in default sized buffers

  2205  * @test Req. under test REQ172.6.4, REQ172.6.5

  2206  */

  2207 TVerdict CTest_MMF_ACOD_U_0016::DoTestStepL()

  2208 	{

  2209 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  2210 	TBool testOK = EFalse;

  2211 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  2213 	if (err)

  2214 		{

  2215 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2216 		return EFail;

  2217 		}

  2218 	else if (!testOK)

  2219 		{

  2220 		INFO_PRINTF1(_L("Test failed"));

  2221 		return EFail;

  2222 		}

  2223 	else

  2224 		return EPass;

  2225 	}

  2227 //------------------------------------------------------------------

  2229 /** @xxxx

  2230  * Constructor

  2231  */

  2232 CTest_MMF_ACOD_U_0017::CTest_MMF_ACOD_U_0017()

  2233 	{

  2234 	// store the name of this test case

  2235 	// this is the name that is used by the script file

  2236 	// Each test step initialises it's own name

  2237 	iTestStepName = _L("MM-MMF-ACOD-U-0017-HP");

  2239 	for (TUint i=0; i<5; i++)

  2240 		{

  2241 		iExpectedSrcBytesProcessed[i] = 0x1000;

  2242 		iExpectedDstBytesAdded[i] = 0x800;

  2244 		if((i%2)==0)//even i

  2245 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  2246 		else		//odd i

  2247 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2248 		}

  2249 	}

  2251 /** @xxxx

  2252  * PCM16 To ALAW Pass in buffers with different max length and length

  2253  * @test Req. under test REQ172.6.4, REQ172.6.5

  2254  */

  2255 TVerdict CTest_MMF_ACOD_U_0017::DoTestStepL()

  2256 	{

  2257 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  2258 	TBool testOK = EFalse;

  2259 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  2261 	if (err)

  2262 		{

  2263 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2264 		return EFail;

  2265 		}

  2266 	else if (!testOK)

  2267 		{

  2268 		INFO_PRINTF1(_L("Test failed"));

  2269 		return EFail;

  2270 		}

  2271 	else

  2272 		return EPass;

  2273 	}

  2275 //------------------------------------------------------------------

  2277 /** @xxxx

  2278  * Constructor

  2279  */

  2280 CTest_MMF_ACOD_U_0018::CTest_MMF_ACOD_U_0018()

  2281 	{

  2282 	// store the name of this test case

  2283 	// this is the name that is used by the script file

  2284 	// Each test step initialises it's own name

  2285 	iTestStepName = _L("MM-MMF-ACOD-U-0018-HP");

  2287 	for (TUint i=0; i<5; i++)

  2288 		{

  2289 		iExpectedSrcBytesProcessed[i] = 0x1000;

  2290 		iExpectedDstBytesAdded[i] = 0x800;

  2291 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2292 		}

  2293 	}

  2295 /** @xxxx

  2296  * PCM16 To ALAW Pass in buffers of optimum size

  2297  * @test Req. under test REQ172.6.4, REQ172.6.5

  2298  */

  2299 TVerdict CTest_MMF_ACOD_U_0018::DoTestStepL()

  2300 	{

  2301 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  2302 	TBool testOK = EFalse;

  2303 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToAlawOptimumSrc, KPCM16ToAlawOptimumDst));

  2305 	if (err)

  2306 		{

  2307 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2308 		return EFail;

  2309 		}

  2310 	else if (!testOK)

  2311 		{

  2312 		INFO_PRINTF1(_L("Test failed"));

  2313 		return EFail;

  2314 		}

  2315 	else

  2316 		return EPass;

  2317 	}

  2319 //------------------------------------------------------------------

  2321 /** @xxxx

  2322  * Constructor

  2323  */

  2324 CTest_MMF_ACOD_U_0019::CTest_MMF_ACOD_U_0019()

  2325 	{

  2326 	// store the name of this test case

  2327 	// this is the name that is used by the script file

  2328 	// Each test step initialises it's own name

  2329 	iTestStepName = _L("MM-MMF-ACOD-U-0019-HP");

  2330 //	iHeapSize = 0x20000;

  2331 	}

  2333 /** @xxxx

  2334  * PCM16 To ALAW Reposition source pointer during conversion

  2335  * @test Req. under test REQ172.11

  2336  */

  2337 TVerdict CTest_MMF_ACOD_U_0019::DoTestStepL()

  2338 	{

  2339 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  2340 	TBool testOK = EFalse;

  2342 	INFO_PRINTF1(_L(">> The PCM16 to ALAW codec doesn't currently store data between calls to ProcessL"));

  2343 	TRAPD(err, testOK = TestRepositionL(codecUid, KDefaultBufferSize, KDefaultBufferSize+30));

  2345 	if (err)

  2346 		{

  2347 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2348 		return EFail;

  2349 		}

  2350 	else if (!testOK)

  2351 		{

  2352 		INFO_PRINTF1(_L("Test failed"));

  2353 		return EFail;

  2354 		}

  2355 	else

  2356 		return EPass;

  2357 	}

  2359 //------------------------------------------------------------------

  2361 /** @xxxx

  2362  * Constructor

  2363  */

  2364 CTest_MMF_ACOD_U_0020::CTest_MMF_ACOD_U_0020()

  2365 	{

  2366 	// store the name of this test case

  2367 	// this is the name that is used by the script file

  2368 	// Each test step initialises it's own name

  2369 	iTestStepName = _L("MM-MMF-ACOD-U-0020-HP");

  2370 	}

  2372 /** @xxxx

  2373  * PCM8 To PCM16 Instantiate codec by FourCC Codes

  2374  * @test Req. under test REQ172.6.2, REQ172.11.4

  2375  */

  2376 TVerdict CTest_MMF_ACOD_U_0020::DoTestStepL()

  2377 	{

  2378 	TBool testOK = EFalse;

  2379 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM8, KMMFFourCCCodePCM16));

  2381 	if (err)

  2382 		{

  2383 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2384 		return EFail;

  2385 		}

  2386 	else if (!testOK)

  2387 		{

  2388 		INFO_PRINTF1(_L("Test failed"));

  2389 		return EFail;

  2390 		}

  2391 	else

  2392 		return EPass;

  2393 	}

  2395 //------------------------------------------------------------------

  2397 /** @xxxx

  2398  * Constructor

  2399  */

  2400 CTest_MMF_ACOD_U_0021::CTest_MMF_ACOD_U_0021()

  2401 	{

  2402 	// store the name of this test case

  2403 	// this is the name that is used by the script file

  2404 	// Each test step initialises it's own name

  2405 	iTestStepName = _L("MM-MMF-ACOD-U-0021-HP");

  2406 	}

  2408 /** @xxxx

  2409  * PCM8 To PCM16 Instantiate codec by UID

  2410  * @test Req. under test REQ172.6.1, REQ172.11.4

  2411  */

  2412 TVerdict CTest_MMF_ACOD_U_0021::DoTestStepL()

  2413 	{

  2414 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  2415 	TBool testOK = EFalse;

  2416 	TRAPD(err, testOK = TestNewL(codecUid));

  2418 	if (err)

  2419 		{

  2420 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2421 		return EFail;

  2422 		}

  2423 	else if (!testOK)

  2424 		{

  2425 		INFO_PRINTF1(_L("Test failed"));

  2426 		return EFail;

  2427 		}

  2428 	else

  2429 		return EPass;

  2430 	}

  2432 //------------------------------------------------------------------

  2434 /** @xxxx

  2435  * Constructor

  2436  */

  2437 CTest_MMF_ACOD_U_0022::CTest_MMF_ACOD_U_0022()

  2438 	{

  2439 	// store the name of this test case

  2440 	// this is the name that is used by the script file

  2441 	// Each test step initialises it's own name

  2442 	iTestStepName = _L("MM-MMF-ACOD-U-0022-HP");

  2444 	for (TUint i=0; i<5; i++)

  2445 		{

  2446 		iExpectedSrcBytesProcessed[i] = 50;

  2447 		iExpectedDstBytesAdded[i] = 100;

  2448 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  2449 		}

  2450 	}

  2452 /** @xxxx

  2453  * PCM8 To PCM16 Pass in small source buffers

  2454  * @test Req. under test REQ172.6.4, REQ172.6.5

  2455  */

  2456 TVerdict CTest_MMF_ACOD_U_0022::DoTestStepL()

  2457 	{

  2458 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  2459 	TBool testOK = EFalse;

  2460 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM8ToPCM16OptimumDst));

  2462 	if (err)

  2463 		{

  2464 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2465 		return EFail;

  2466 		}

  2467 	else if (!testOK)

  2468 		{

  2469 		INFO_PRINTF1(_L("Test failed"));

  2470 		return EFail;

  2471 		}

  2472 	else

  2473 		return EPass;

  2474 	}

  2476 //------------------------------------------------------------------

  2478 /** @xxxx

  2479  * Constructor

  2480  */

  2481 CTest_MMF_ACOD_U_0023::CTest_MMF_ACOD_U_0023()

  2482 	{

  2483 	// store the name of this test case

  2484 	// this is the name that is used by the script file

  2485 	// Each test step initialises it's own name

  2486 	iTestStepName = _L("MM-MMF-ACOD-U-0023-HP");

  2488 	for (TUint i=0; i<5; i++)

  2489 		{

  2490 		iExpectedSrcBytesProcessed[i] = 25;

  2491 		iExpectedDstBytesAdded[i] = 50;

  2492 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  2493 		}

  2494 	}

  2496 /** @xxxx

  2497  * PCM8 To PCM16 Pass in small dest buffers

  2498  * @test Req. under test REQ172.6.4, REQ172.6.5

  2499  */

  2500 TVerdict CTest_MMF_ACOD_U_0023::DoTestStepL()

  2501 	{

  2502 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  2503 	TBool testOK = EFalse;

  2504 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM8ToPCM16OptimumSrc, KSmallBufferSize));

  2506 	if (err)

  2507 		{

  2508 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2509 		return EFail;

  2510 		}

  2511 	else if (!testOK)

  2512 		{

  2513 		INFO_PRINTF1(_L("Test failed"));

  2514 		return EFail;

  2515 		}

  2516 	else

  2517 		return EPass;

  2518 	}

  2520 //------------------------------------------------------------------

  2522 /** @xxxx

  2523  * Constructor

  2524  */

  2525 CTest_MMF_ACOD_U_0024::CTest_MMF_ACOD_U_0024()

  2526 	{

  2527 	// store the name of this test case

  2528 	// this is the name that is used by the script file

  2529 	// Each test step initialises it's own name

  2530 	iTestStepName = _L("MM-MMF-ACOD-U-0024-HP");

  2531 	iHeapSize = 0x20000;

  2533 	for (TUint i=0; i<5; i++)

  2534 		{

  2535 		iExpectedSrcBytesProcessed[i] = 5000;

  2536 		iExpectedDstBytesAdded[i] = 10000;

  2538 		if((i%2)==0)//even i

  2539 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  2540 		else		//odd i

  2541 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2542 		}

  2543 	}

  2545 /** @xxxx

  2546  * PCM8 To PCM16 Pass in large buffers

  2547  * @test Req. under test REQ172.6.4, REQ172.6.5

  2548  */

  2549 TVerdict CTest_MMF_ACOD_U_0024::DoTestStepL()

  2550 	{

  2551 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  2552 	TBool testOK = EFalse;

  2553 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  2555 	if (err)

  2556 		{

  2557 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2558 		return EFail;

  2559 		}

  2560 	else if (!testOK)

  2561 		{

  2562 		INFO_PRINTF1(_L("Test failed"));

  2563 		return EFail;

  2564 		}

  2565 	else

  2566 		return EPass;

  2567 	}

  2569 //------------------------------------------------------------------

  2571 /** @xxxx

  2572  * Constructor

  2573  */

  2574 CTest_MMF_ACOD_U_0025::CTest_MMF_ACOD_U_0025()

  2575 	{

  2576 	// store the name of this test case

  2577 	// this is the name that is used by the script file

  2578 	// Each test step initialises it's own name

  2579 	iTestStepName = _L("MM-MMF-ACOD-U-0025-HP");

  2581 	for (TUint i=0; i<5; i++)

  2582 		{

  2583 		iExpectedSrcBytesProcessed[i] = 0x800;

  2584 		iExpectedDstBytesAdded[i] = 0x1000;

  2586 		if((i%2)==0)//even i

  2587 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  2588 		else		//odd i

  2589 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2590 		}

  2591 	}

  2593 /** @xxxx

  2594  * PCM8 To PCM16 Pass in default sized buffers

  2595  * @test Req. under test REQ172.6.4, REQ172.6.5

  2596  */

  2597 TVerdict CTest_MMF_ACOD_U_0025::DoTestStepL()

  2598 	{

  2599 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  2600 	TBool testOK = EFalse;

  2601 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  2603 	if (err)

  2604 		{

  2605 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2606 		return EFail;

  2607 		}

  2608 	else if (!testOK)

  2609 		{

  2610 		INFO_PRINTF1(_L("Test failed"));

  2611 		return EFail;

  2612 		}

  2613 	else

  2614 		return EPass;

  2615 	}

  2617 //------------------------------------------------------------------

  2619 /** @xxxx

  2620  * Constructor

  2621  */

  2622 CTest_MMF_ACOD_U_0026::CTest_MMF_ACOD_U_0026()

  2623 	{

  2624 	// store the name of this test case

  2625 	// this is the name that is used by the script file

  2626 	// Each test step initialises it's own name

  2627 	iTestStepName = _L("MM-MMF-ACOD-U-0026-HP");

  2629 	for (TUint i=0; i<5; i++)

  2630 		{

  2631 		iExpectedSrcBytesProcessed[i] = 0x800;

  2632 		iExpectedDstBytesAdded[i] = 0x1000;

  2634 		if((i%2)==0)//even i

  2635 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  2636 		else		//odd i

  2637 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2638 		}

  2639 	}

  2641 /** @xxxx

  2642  * PCM8 To PCM16 Pass in buffers with different max length and length

  2643  * @test Req. under test REQ172.6.4, REQ172.6.5

  2644  */

  2645 TVerdict CTest_MMF_ACOD_U_0026::DoTestStepL()

  2646 	{

  2647 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  2648 	TBool testOK = EFalse;

  2649 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  2651 	if (err)

  2652 		{

  2653 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2654 		return EFail;

  2655 		}

  2656 	else if (!testOK)

  2657 		{

  2658 		INFO_PRINTF1(_L("Test failed"));

  2659 		return EFail;

  2660 		}

  2661 	else

  2662 		return EPass;

  2663 	}

  2665 //------------------------------------------------------------------

  2667 /** @xxxx

  2668  * Constructor

  2669  */

  2670 CTest_MMF_ACOD_U_0027::CTest_MMF_ACOD_U_0027()

  2671 	{

  2672 	// store the name of this test case

  2673 	// this is the name that is used by the script file

  2674 	// Each test step initialises it's own name

  2675 	iTestStepName = _L("MM-MMF-ACOD-U-0027-HP");

  2677 	for (TUint i=0; i<5; i++)

  2678 		{

  2679 		iExpectedSrcBytesProcessed[i] = 0x800;

  2680 		iExpectedDstBytesAdded[i] = 0x1000;

  2681 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2682 		}

  2683 	}

  2685 /** @xxxx

  2686  * PCM8 To PCM16 Pass in buffers of optimum size

  2687  * @test Req. under test REQ172.6.4, REQ172.6.5

  2688  */

  2689 TVerdict CTest_MMF_ACOD_U_0027::DoTestStepL()

  2690 	{

  2691 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  2692 	TBool testOK = EFalse;

  2693 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM8ToPCM16OptimumSrc, KPCM8ToPCM16OptimumDst));

  2695 	if (err)

  2696 		{

  2697 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2698 		return EFail;

  2699 		}

  2700 	else if (!testOK)

  2701 		{

  2702 		INFO_PRINTF1(_L("Test failed"));

  2703 		return EFail;

  2704 		}

  2705 	else

  2706 		return EPass;

  2707 	}

  2709 //------------------------------------------------------------------

  2711 /** @xxxx

  2712  * Constructor

  2713  */

  2714 CTest_MMF_ACOD_U_0028::CTest_MMF_ACOD_U_0028()

  2715 	{

  2716 	// store the name of this test case

  2717 	// this is the name that is used by the script file

  2718 	// Each test step initialises it's own name

  2719 	iTestStepName = _L("MM-MMF-ACOD-U-0028-HP");

  2720 //	iHeapSize = 0x20000;

  2721 	}

  2723 /** @xxxx

  2724  * PCM8 To PCM16 Reposition source pointer during conversion

  2725  * @test Req. under test REQ172.11

  2726  */

  2727 TVerdict CTest_MMF_ACOD_U_0028::DoTestStepL()

  2728 	{

  2729 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  2730 	TBool testOK = EFalse;

  2732 	INFO_PRINTF1(_L(">> The PCM8 to PCM16 codec doesn't currently store data between calls to ProcessL"));

  2733 	TRAPD(err, testOK = TestRepositionL(codecUid, KPCM8ToPCM16OptimumSrc, KPCM8ToPCM16OptimumDst+30));

  2735 	if (err)

  2736 		{

  2737 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2738 		return EFail;

  2739 		}

  2740 	else if (!testOK)

  2741 		{

  2742 		INFO_PRINTF1(_L("Test failed"));

  2743 		return EFail;

  2744 		}

  2745 	else

  2746 		return EPass;

  2747 	}

  2749 //------------------------------------------------------------------

  2751 /** @xxxx

  2752  * Constructor

  2753  */

  2754 CTest_MMF_ACOD_U_0029::CTest_MMF_ACOD_U_0029()

  2755 	{

  2756 	// store the name of this test case

  2757 	// this is the name that is used by the script file

  2758 	// Each test step initialises it's own name

  2759 	iTestStepName = _L("MM-MMF-ACOD-U-0029-HP");

  2760 	}

  2762 /** @xxxx

  2763  * PCM16 To PCM8 Instantiate codec by FourCC Codes

  2764  * @test Req. under test REQ172.6.2, REQ172.11.5

  2765  */

  2766 TVerdict CTest_MMF_ACOD_U_0029::DoTestStepL()

  2767 	{

  2768 	TBool testOK = EFalse;

  2769 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodePCM8));

  2771 	if (err)

  2772 		{

  2773 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2774 		return EFail;

  2775 		}

  2776 	else if (!testOK)

  2777 		{

  2778 		INFO_PRINTF1(_L("Test failed"));

  2779 		return EFail;

  2780 		}

  2781 	else

  2782 		return EPass;

  2783 	}

  2785 //------------------------------------------------------------------

  2787 /** @xxxx

  2788  * Constructor

  2789  */

  2790 CTest_MMF_ACOD_U_0030::CTest_MMF_ACOD_U_0030()

  2791 	{

  2792 	// store the name of this test case

  2793 	// this is the name that is used by the script file

  2794 	// Each test step initialises it's own name

  2795 	iTestStepName = _L("MM-MMF-ACOD-U-0030-HP");

  2796 	}

  2798 /** @xxxx

  2799  * PCM16 To PCM8 Instantiate codec by UID

  2800  * @test Req. under test REQ172.6.1, REQ172.11.5

  2801  */

  2802 TVerdict CTest_MMF_ACOD_U_0030::DoTestStepL()

  2803 	{

  2804 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  2805 	TBool testOK = EFalse;

  2806 	TRAPD(err, testOK = TestNewL(codecUid));

  2808 	if (err)

  2809 		{

  2810 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2811 		return EFail;

  2812 		}

  2813 	else if (!testOK)

  2814 		{

  2815 		INFO_PRINTF1(_L("Test failed"));

  2816 		return EFail;

  2817 		}

  2818 	else

  2819 		return EPass;

  2820 	}

  2822 //------------------------------------------------------------------

  2824 /** @xxxx

  2825  * Constructor

  2826  */

  2827 CTest_MMF_ACOD_U_0031::CTest_MMF_ACOD_U_0031()

  2828 	{

  2829 	// store the name of this test case

  2830 	// this is the name that is used by the script file

  2831 	// Each test step initialises it's own name

  2832 	iTestStepName = _L("MM-MMF-ACOD-U-0031-HP");

  2834 	for (TUint i=0; i<5; i++)

  2835 		{

  2836 		iExpectedSrcBytesProcessed[i] = 50;

  2837 		iExpectedDstBytesAdded[i] = 25;

  2838 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  2839 		}

  2840 	}

  2842 /** @xxxx

  2843  * PCM16 To PCM8 Pass in small source buffers

  2844  * @test Req. under test REQ172.6.4, REQ172.6.5

  2845  */

  2846 TVerdict CTest_MMF_ACOD_U_0031::DoTestStepL()

  2847 	{

  2848 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  2849 	TBool testOK = EFalse;

  2850 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM16ToPCM8OptimumDst));

  2852 	if (err)

  2853 		{

  2854 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2855 		return EFail;

  2856 		}

  2857 	else if (!testOK)

  2858 		{

  2859 		INFO_PRINTF1(_L("Test failed"));

  2860 		return EFail;

  2861 		}

  2862 	else

  2863 		return EPass;

  2864 	}

  2866 //------------------------------------------------------------------

  2868 /** @xxxx

  2869  * Constructor

  2870  */

  2871 CTest_MMF_ACOD_U_0032::CTest_MMF_ACOD_U_0032()

  2872 	{

  2873 	// store the name of this test case

  2874 	// this is the name that is used by the script file

  2875 	// Each test step initialises it's own name

  2876 	iTestStepName = _L("MM-MMF-ACOD-U-0032-HP");

  2878 	for (TUint i=0; i<5; i++)

  2879 		{

  2880 		iExpectedSrcBytesProcessed[i] = 100;

  2881 		iExpectedDstBytesAdded[i] = 50;

  2882 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  2883 		}

  2884 	}

  2886 /** @xxxx

  2887  * PCM16 To PCM8 Pass in small dest buffers

  2888  * @test Req. under test REQ172.6.4, REQ172.6.5

  2889  */

  2890 TVerdict CTest_MMF_ACOD_U_0032::DoTestStepL()

  2891 	{

  2892 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  2893 	TBool testOK = EFalse;

  2894 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCM8OptimumSrc, KSmallBufferSize));

  2896 	if (err)

  2897 		{

  2898 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2899 		return EFail;

  2900 		}

  2901 	else if (!testOK)

  2902 		{

  2903 		INFO_PRINTF1(_L("Test failed"));

  2904 		return EFail;

  2905 		}

  2906 	else

  2907 		return EPass;

  2908 	}

  2910 //------------------------------------------------------------------

  2912 /** @xxxx

  2913  * Constructor

  2914  */

  2915 CTest_MMF_ACOD_U_0033::CTest_MMF_ACOD_U_0033()

  2916 	{

  2917 	// store the name of this test case

  2918 	// this is the name that is used by the script file

  2919 	// Each test step initialises it's own name

  2920 	iTestStepName = _L("MM-MMF-ACOD-U-0033-HP");

  2921 	iHeapSize = 0x20000;

  2923 	for (TUint i=0; i<5; i++)

  2924 		{

  2925 		iExpectedSrcBytesProcessed[i] = 10000;

  2926 		iExpectedDstBytesAdded[i] = 5000;

  2928 		if((i%2)==0)//even i

  2929 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  2930 		else		//odd i

  2931 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2932 		}

  2933 	}

  2935 /** @xxxx

  2936  * PCM16 To PCM8 Pass in large buffers

  2937  * @test Req. under test REQ172.6.4, REQ172.6.5

  2938  */

  2939 TVerdict CTest_MMF_ACOD_U_0033::DoTestStepL()

  2940 	{

  2941 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  2942 	TBool testOK = EFalse;

  2943 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  2945 	if (err)

  2946 		{

  2947 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2948 		return EFail;

  2949 		}

  2950 	else if (!testOK)

  2951 		{

  2952 		INFO_PRINTF1(_L("Test failed"));

  2953 		return EFail;

  2954 		}

  2955 	else

  2956 		return EPass;

  2957 	}

  2959 //------------------------------------------------------------------

  2961 /** @xxxx

  2962  * Constructor

  2963  */

  2964 CTest_MMF_ACOD_U_0034::CTest_MMF_ACOD_U_0034()

  2965 	{

  2966 	// store the name of this test case

  2967 	// this is the name that is used by the script file

  2968 	// Each test step initialises it's own name

  2969 	iTestStepName = _L("MM-MMF-ACOD-U-0034-HP");

  2971 	for (TUint i=0; i<5; i++)

  2972 		{

  2973 		iExpectedSrcBytesProcessed[i] = 0x1000;

  2974 		iExpectedDstBytesAdded[i] = 0x800;

  2976 		if((i%2)==0)//even i

  2977 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  2978 		else		//odd i

  2979 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  2980 		}

  2981 	}

  2983 /** @xxxx

  2984  * PCM16 To PCM8 Pass in default sized buffers

  2985  * @test Req. under test REQ172.6.4, REQ172.6.5

  2986  */

  2987 TVerdict CTest_MMF_ACOD_U_0034::DoTestStepL()

  2988 	{

  2989 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  2990 	TBool testOK = EFalse;

  2991 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  2993 	if (err)

  2994 		{

  2995 		INFO_PRINTF2(_L("Test left with status %d"), err);

  2996 		return EFail;

  2997 		}

  2998 	else if (!testOK)

  2999 		{

  3000 		INFO_PRINTF1(_L("Test failed"));

  3001 		return EFail;

  3002 		}

  3003 	else

  3004 		return EPass;

  3005 	}

  3007 //------------------------------------------------------------------

  3009 /** @xxxx

  3010  * Constructor

  3011  */

  3012 CTest_MMF_ACOD_U_0035::CTest_MMF_ACOD_U_0035()

  3013 	{

  3014 	// store the name of this test case

  3015 	// this is the name that is used by the script file

  3016 	// Each test step initialises it's own name

  3017 	iTestStepName = _L("MM-MMF-ACOD-U-0035-HP");

  3019 	for (TUint i=0; i<5; i++)

  3020 		{

  3021 		iExpectedSrcBytesProcessed[i] = 0x1000;

  3022 		iExpectedDstBytesAdded[i] = 0x800;

  3024 		if((i%2)==0)//even i

  3025 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  3026 		else		//odd i

  3027 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3028 		}

  3029 	}

  3031 /** @xxxx

  3032  * PCM16 To PCM8 Pass in buffers with different max length and length

  3033  * @test Req. under test REQ172.6.4, REQ172.6.5

  3034  */

  3035 TVerdict CTest_MMF_ACOD_U_0035::DoTestStepL()

  3036 	{

  3037 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  3038 	TBool testOK = EFalse;

  3039 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  3041 	if (err)

  3042 		{

  3043 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3044 		return EFail;

  3045 		}

  3046 	else if (!testOK)

  3047 		{

  3048 		INFO_PRINTF1(_L("Test failed"));

  3049 		return EFail;

  3050 		}

  3051 	else

  3052 		return EPass;

  3053 	}

  3055 //------------------------------------------------------------------

  3057 /** @xxxx

  3058  * Constructor

  3059  */

  3060 CTest_MMF_ACOD_U_0036::CTest_MMF_ACOD_U_0036()

  3061 	{

  3062 	// store the name of this test case

  3063 	// this is the name that is used by the script file

  3064 	// Each test step initialises it's own name

  3065 	iTestStepName = _L("MM-MMF-ACOD-U-0036-HP");

  3067 	for (TUint i=0; i<5; i++)

  3068 		{

  3069 		iExpectedSrcBytesProcessed[i] = 0x1000;

  3070 		iExpectedDstBytesAdded[i] = 0x800;

  3071 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3072 		}

  3073 	}

  3075 /** @xxxx

  3076  * PCM16 To PCM8 Pass in buffers of optimum size

  3077  * @test Req. under test REQ172.6.4, REQ172.6.5

  3078  */

  3079 TVerdict CTest_MMF_ACOD_U_0036::DoTestStepL()

  3080 	{

  3081 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  3082 	TBool testOK = EFalse;

  3083 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCM8OptimumSrc, KPCM16ToPCM8OptimumDst));

  3085 	if (err)

  3086 		{

  3087 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3088 		return EFail;

  3089 		}

  3090 	else if (!testOK)

  3091 		{

  3092 		INFO_PRINTF1(_L("Test failed"));

  3093 		return EFail;

  3094 		}

  3095 	else

  3096 		return EPass;

  3097 	}

  3099 //------------------------------------------------------------------

  3101 /** @xxxx

  3102  * Constructor

  3103  */

  3104 CTest_MMF_ACOD_U_0037::CTest_MMF_ACOD_U_0037()

  3105 	{

  3106 	// store the name of this test case

  3107 	// this is the name that is used by the script file

  3108 	// Each test step initialises it's own name

  3109 	iTestStepName = _L("MM-MMF-ACOD-U-0037-HP");

  3110 	}

  3112 /** @xxxx

  3113  * PCM16 To PCM8 Reposition source pointer during conversion

  3114  * @test Req. under test REQ172.11

  3115  */

  3116 TVerdict CTest_MMF_ACOD_U_0037::DoTestStepL()

  3117 	{

  3118 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  3119 	TBool testOK = EFalse;

  3121 	INFO_PRINTF1(_L(">> The PCM16 to PCM8 codec doesn't currently store data between calls to ProcessL"));

  3122 	TRAPD(err, testOK = TestRepositionL(codecUid, KDefaultBufferSize, KDefaultBufferSize+30));

  3124 	if (err)

  3125 		{

  3126 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3127 		return EFail;

  3128 		}

  3129 	else if (!testOK)

  3130 		{

  3131 		INFO_PRINTF1(_L("Test failed"));

  3132 		return EFail;

  3133 		}

  3134 	else

  3135 		return EPass;

  3136 	}

  3138 //------------------------------------------------------------------

  3140 /** @xxxx

  3141  * Constructor

  3142  */

  3143 CTest_MMF_ACOD_U_0038::CTest_MMF_ACOD_U_0038()

  3144 	{

  3145 	// store the name of this test case

  3146 	// this is the name that is used by the script file

  3147 	// Each test step initialises it's own name

  3148 	iTestStepName = _L("MM-MMF-ACOD-U-0038-HP");

  3149 	}

  3151 /** @xxxx

  3152  * PCM16 To PCM16B Instantiate codec by FourCC Codes

  3153  * @test Req. under test REQ172.6.2, REQ172.11.6

  3154  */

  3155 TVerdict CTest_MMF_ACOD_U_0038::DoTestStepL()

  3156 	{

  3157 	TBool testOK = EFalse;

  3158 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodePCM16B));

  3160 	if (err)

  3161 		{

  3162 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3163 		return EFail;

  3164 		}

  3165 	else if (!testOK)

  3166 		{

  3167 		INFO_PRINTF1(_L("Test failed"));

  3168 		return EFail;

  3169 		}

  3170 	else

  3171 		return EPass;

  3172 	}

  3174 //------------------------------------------------------------------

  3176 /** @xxxx

  3177  * Constructor

  3178  */

  3179 CTest_MMF_ACOD_U_0039::CTest_MMF_ACOD_U_0039()

  3180 	{

  3181 	// store the name of this test case

  3182 	// this is the name that is used by the script file

  3183 	// Each test step initialises it's own name

  3184 	iTestStepName = _L("MM-MMF-ACOD-U-0039-HP");

  3185 	}

  3187 /** @xxxx

  3188  * PCM16B To PCM16 Instantiate codec by FourCC Codes

  3189  * @test Req. under test REQ172.6.2, REQ172.11.6

  3190  */

  3191 TVerdict CTest_MMF_ACOD_U_0039::DoTestStepL()

  3192 	{

  3193 	TBool testOK = EFalse;

  3194 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16B, KMMFFourCCCodePCM16));

  3196 	if (err)

  3197 		{

  3198 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3199 		return EFail;

  3200 		}

  3201 	else if (!testOK)

  3202 		{

  3203 		INFO_PRINTF1(_L("Test failed"));

  3204 		return EFail;

  3205 		}

  3206 	else

  3207 		return EPass;

  3208 	}

  3210 //------------------------------------------------------------------

  3212 /** @xxxx

  3213  * Constructor

  3214  */

  3215 CTest_MMF_ACOD_U_0040::CTest_MMF_ACOD_U_0040()

  3216 	{

  3217 	// store the name of this test case

  3218 	// this is the name that is used by the script file

  3219 	// Each test step initialises it's own name

  3220 	iTestStepName = _L("MM-MMF-ACOD-U-0040-HP");

  3221 	}

  3223 /** @xxxx

  3224  * PCMU16 To PCMU16B Instantiate codec by FourCC Codes

  3225  * @test Req. under test REQ172.6.2, REQ172.11.6

  3226  */

  3227 TVerdict CTest_MMF_ACOD_U_0040::DoTestStepL()

  3228 	{

  3229 	TBool testOK = EFalse;

  3230 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCMU16, KMMFFourCCCodePCMU16B));

  3232 	if (err)

  3233 		{

  3234 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3235 		return EFail;

  3236 		}

  3237 	else if (!testOK)

  3238 		{

  3239 		INFO_PRINTF1(_L("Test failed"));

  3240 		return EFail;

  3241 		}

  3242 	else

  3243 		return EPass;

  3244 	}

  3246 //------------------------------------------------------------------

  3248 /** @xxxx

  3249  * Constructor

  3250  */

  3251 CTest_MMF_ACOD_U_0041::CTest_MMF_ACOD_U_0041()

  3252 	{

  3253 	// store the name of this test case

  3254 	// this is the name that is used by the script file

  3255 	// Each test step initialises it's own name

  3256 	iTestStepName = _L("MM-MMF-ACOD-U-0041-HP");

  3257 	}

  3259 /** @xxxx

  3260  * PCMU16B To PCMU16 Instantiate codec by FourCC Codes

  3261  * @test Req. under test REQ172.6.2, REQ172.11.6

  3262  */

  3263 TVerdict CTest_MMF_ACOD_U_0041::DoTestStepL()

  3264 	{

  3265 	TBool testOK = EFalse;

  3266 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCMU16B, KMMFFourCCCodePCMU16));

  3268 	if (err)

  3269 		{

  3270 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3271 		return EFail;

  3272 		}

  3273 	else if (!testOK)

  3274 		{

  3275 		INFO_PRINTF1(_L("Test failed"));

  3276 		return EFail;

  3277 		}

  3278 	else

  3279 		return EPass;

  3280 	}

  3282 //------------------------------------------------------------------

  3284 /** @xxxx

  3285  * Constructor

  3286  */

  3287 CTest_MMF_ACOD_U_0042::CTest_MMF_ACOD_U_0042()

  3288 	{

  3289 	// store the name of this test case

  3290 	// this is the name that is used by the script file

  3291 	// Each test step initialises it's own name

  3292 	iTestStepName = _L("MM-MMF-ACOD-U-0042-HP");

  3293 	}

  3295 /** @xxxx

  3296  * PCM16 To PCM16B Instantiate codec by UID

  3297  * @test Req. under test REQ172.6.1, REQ172.11.6

  3298  */

  3299 TVerdict CTest_MMF_ACOD_U_0042::DoTestStepL()

  3300 	{

  3301 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  3302 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  3303 	TBool testOK = EFalse;

  3304 	TRAPD(err, testOK = TestNewL(codecUid));

  3306 	if (err)

  3307 		{

  3308 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3309 		return EFail;

  3310 		}

  3311 	else if (!testOK)

  3312 		{

  3313 		INFO_PRINTF1(_L("Test failed"));

  3314 		return EFail;

  3315 		}

  3316 	else

  3317 		return EPass;

  3318 	}

  3320 //------------------------------------------------------------------

  3322 /** @xxxx

  3323  * Constructor

  3324  */

  3325 CTest_MMF_ACOD_U_0043::CTest_MMF_ACOD_U_0043()

  3326 	{

  3327 	// store the name of this test case

  3328 	// this is the name that is used by the script file

  3329 	// Each test step initialises it's own name

  3330 	iTestStepName = _L("MM-MMF-ACOD-U-0043-HP");

  3332 	for (TUint i=0; i<5; i++)

  3333 		{

  3334 		iExpectedSrcBytesProcessed[i] = 50;

  3335 		iExpectedDstBytesAdded[i] = 50;

  3336 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  3337 		}

  3338 	}

  3340 /** @xxxx

  3341  * PCM16 To PCM16B Pass in small source buffers

  3342  * @test Req. under test REQ172.6.4, REQ172.6.5

  3343  */

  3344 TVerdict CTest_MMF_ACOD_U_0043::DoTestStepL()

  3345 	{

  3346 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  3347 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  3348 	TBool testOK = EFalse;

  3349 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM16ToPCM16BOptimumDst));

  3351 	if (err)

  3352 		{

  3353 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3354 		return EFail;

  3355 		}

  3356 	else if (!testOK)

  3357 		{

  3358 		INFO_PRINTF1(_L("Test failed"));

  3359 		return EFail;

  3360 		}

  3361 	else

  3362 		return EPass;

  3363 	}

  3365 //------------------------------------------------------------------

  3367 /** @xxxx

  3368  * Constructor

  3369  */

  3370 CTest_MMF_ACOD_U_0044::CTest_MMF_ACOD_U_0044()

  3371 	{

  3372 	// store the name of this test case

  3373 	// this is the name that is used by the script file

  3374 	// Each test step initialises it's own name

  3375 	iTestStepName = _L("MM-MMF-ACOD-U-0044-HP");

  3376 	iHeapSize = 0x20000;

  3377 	for (TUint i=0; i<5; i++)

  3378 		{

  3379 		iExpectedSrcBytesProcessed[i] = 50;

  3380 		iExpectedDstBytesAdded[i] = 50;

  3381 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  3382 		}

  3383 	}

  3385 /** @xxxx

  3386  * PCM16 To PCM16B Pass in small dest buffers

  3387  * @test Req. under test REQ172.6.4, REQ172.6.5

  3388  */

  3389 TVerdict CTest_MMF_ACOD_U_0044::DoTestStepL()

  3390 	{

  3391 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  3392 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  3393 	TBool testOK = EFalse;

  3394 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCM16BOptimumSrc, KSmallBufferSize));

  3396 	if (err)

  3397 		{

  3398 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3399 		return EFail;

  3400 		}

  3401 	else if (!testOK)

  3402 		{

  3403 		INFO_PRINTF1(_L("Test failed"));

  3404 		return EFail;

  3405 		}

  3406 	else

  3407 		return EPass;

  3408 	}

  3410 //------------------------------------------------------------------

  3412 /** @xxxx

  3413  * Constructor

  3414  */

  3415 CTest_MMF_ACOD_U_0045::CTest_MMF_ACOD_U_0045()

  3416 	{

  3417 	// store the name of this test case

  3418 	// this is the name that is used by the script file

  3419 	// Each test step initialises it's own name

  3420 	iTestStepName = _L("MM-MMF-ACOD-U-0045-HP");

  3421 	iHeapSize = 0x20000;

  3422 	for (TUint i=0; i<5; i++)

  3423 		{

  3424 		iExpectedSrcBytesProcessed[i] = 10000;

  3425 		iExpectedDstBytesAdded[i] = 10000;

  3426 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3427 		}

  3428 	}

  3430 /** @xxxx

  3431  * PCM16 To PCM16B Pass in large buffers

  3432  * @test Req. under test REQ172.6.4, REQ172.6.5

  3433  */

  3434 TVerdict CTest_MMF_ACOD_U_0045::DoTestStepL()

  3435 	{

  3436 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  3437 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  3438 	TBool testOK = EFalse;

  3439 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  3441 	if (err)

  3442 		{

  3443 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3444 		return EFail;

  3445 		}

  3446 	else if (!testOK)

  3447 		{

  3448 		INFO_PRINTF1(_L("Test failed"));

  3449 		return EFail;

  3450 		}

  3451 	else

  3452 		return EPass;

  3453 	}

  3455 //------------------------------------------------------------------

  3457 /** @xxxx

  3458  * Constructor

  3459  */

  3460 CTest_MMF_ACOD_U_0046::CTest_MMF_ACOD_U_0046()

  3461 	{

  3462 	// store the name of this test case

  3463 	// this is the name that is used by the script file

  3464 	// Each test step initialises it's own name

  3465 	iTestStepName = _L("MM-MMF-ACOD-U-0046-HP");

  3467 	for (TUint i=0; i<5; i++)

  3468 		{

  3469 		iExpectedSrcBytesProcessed[i] = 0x1000;

  3470 		iExpectedDstBytesAdded[i] = 0x1000;

  3471 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3472 		}

  3473 	}

  3475 /** @xxxx

  3476  * PCM16 To PCM16B Pass in default sized buffers

  3477  * @test Req. under test REQ172.6.4, REQ172.6.5

  3478  */

  3479 TVerdict CTest_MMF_ACOD_U_0046::DoTestStepL()

  3480 	{

  3481 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  3482 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  3483 	TBool testOK = EFalse;

  3484 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  3486 	if (err)

  3487 		{

  3488 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3489 		return EFail;

  3490 		}

  3491 	else if (!testOK)

  3492 		{

  3493 		INFO_PRINTF1(_L("Test failed"));

  3494 		return EFail;

  3495 		}

  3496 	else

  3497 		return EPass;

  3498 	}

  3500 //------------------------------------------------------------------

  3502 /** @xxxx

  3503  * Constructor

  3504  */

  3505 CTest_MMF_ACOD_U_0047::CTest_MMF_ACOD_U_0047()

  3506 	{

  3507 	// store the name of this test case

  3508 	// this is the name that is used by the script file

  3509 	// Each test step initialises it's own name

  3510 	iTestStepName = _L("MM-MMF-ACOD-U-0047-HP");

  3512 	for (TUint i=0; i<5; i++)

  3513 		{

  3514 		iExpectedSrcBytesProcessed[i] = 0x1000;

  3515 		iExpectedDstBytesAdded[i] = 0x1000;

  3516 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3517 		}

  3518 	}

  3520 /** @xxxx

  3521  * PCM16 To PCM16B Pass in buffers with different max length and length

  3522  * @test Req. under test REQ172.6.4, REQ172.6.5

  3523  */

  3524 TVerdict CTest_MMF_ACOD_U_0047::DoTestStepL()

  3525 	{

  3526 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  3527 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  3528 	TBool testOK = EFalse;

  3529 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  3531 	if (err)

  3532 		{

  3533 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3534 		return EFail;

  3535 		}

  3536 	else if (!testOK)

  3537 		{

  3538 		INFO_PRINTF1(_L("Test failed"));

  3539 		return EFail;

  3540 		}

  3541 	else

  3542 		return EPass;

  3543 	}

  3545 //------------------------------------------------------------------

  3547 /** @xxxx

  3548  * Constructor

  3549  */

  3550 CTest_MMF_ACOD_U_0048::CTest_MMF_ACOD_U_0048()

  3551 	{

  3552 	// store the name of this test case

  3553 	// this is the name that is used by the script file

  3554 	// Each test step initialises it's own name

  3555 	iTestStepName = _L("MM-MMF-ACOD-U-0048-HP");

  3557 	for (TUint i=0; i<5; i++)

  3558 		{

  3559 		iExpectedSrcBytesProcessed[i] = 0x1000;

  3560 		iExpectedDstBytesAdded[i] = 0x1000;

  3561 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3562 		}

  3563 	}

  3565 /** @xxxx

  3566  * PCM16 To PCM16B Pass in buffers of optimum size

  3567  * @test Req. under test REQ172.6.4, REQ172.6.5

  3568  */

  3569 TVerdict CTest_MMF_ACOD_U_0048::DoTestStepL()

  3570 	{

  3571 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  3572 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  3573 	TBool testOK = EFalse;

  3574 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCM16BOptimumSrc, KPCM16ToPCM16BOptimumDst));

  3576 	if (err)

  3577 		{

  3578 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3579 		return EFail;

  3580 		}

  3581 	else if (!testOK)

  3582 		{

  3583 		INFO_PRINTF1(_L("Test failed"));

  3584 		return EFail;

  3585 		}

  3586 	else

  3587 		return EPass;

  3588 	}

  3590 //------------------------------------------------------------------

  3592 /** @xxxx

  3593  * Constructor

  3594  */

  3595 CTest_MMF_ACOD_U_0049::CTest_MMF_ACOD_U_0049()

  3596 	{

  3597 	// store the name of this test case

  3598 	// this is the name that is used by the script file

  3599 	// Each test step initialises it's own name

  3600 	iTestStepName = _L("MM-MMF-ACOD-U-0049-HP");

  3601 	}

  3603 /** @xxxx

  3604  * PCM16 To PCM16B Reposition source pointer during conversion

  3605  * @test Req. under test REQ172.11

  3606  */

  3607 TVerdict CTest_MMF_ACOD_U_0049::DoTestStepL()

  3608 	{

  3609 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  3610 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  3611 	TBool testOK = EFalse;

  3613 	INFO_PRINTF1(_L(">> The PCM16 to PCM16B codec doesn't currently store data between calls to ProcessL"));

  3614 	TRAPD(err, testOK = TestRepositionL(codecUid, KDefaultBufferSize, KDefaultBufferSize+30));

  3616 	if (err)

  3617 		{

  3618 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3619 		return EFail;

  3620 		}

  3621 	else if (!testOK)

  3622 		{

  3623 		INFO_PRINTF1(_L("Test failed"));

  3624 		return EFail;

  3625 		}

  3626 	else

  3627 		return EPass;

  3628 	}

  3630 //------------------------------------------------------------------

  3632 /** @xxxx

  3633  * Constructor

  3634  */

  3635 CTest_MMF_ACOD_U_0050::CTest_MMF_ACOD_U_0050()

  3636 	{

  3637 	// store the name of this test case

  3638 	// this is the name that is used by the script file

  3639 	// Each test step initialises it's own name

  3640 	iTestStepName = _L("MM-MMF-ACOD-U-0050-HP");

  3641 	}

  3643 /** @xxxx

  3644  * PCM16 To PCMU16B Instantiate codec by FourCC Codes

  3645  * @test Req. under test REQ172.6.2

  3646  */

  3647 TVerdict CTest_MMF_ACOD_U_0050::DoTestStepL()

  3648 	{

  3649 	TBool testOK = EFalse;

  3650 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodePCMU16B));

  3652 	if (err)

  3653 		{

  3654 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3655 		return EFail;

  3656 		}

  3657 	else if (!testOK)

  3658 		{

  3659 		INFO_PRINTF1(_L("Test failed"));

  3660 		return EFail;

  3661 		}

  3662 	else

  3663 		return EPass;

  3664 	}

  3666 //------------------------------------------------------------------

  3668 /** @xxxx

  3669  * Constructor

  3670  */

  3671 CTest_MMF_ACOD_U_0051::CTest_MMF_ACOD_U_0051()

  3672 	{

  3673 	// store the name of this test case

  3674 	// this is the name that is used by the script file

  3675 	// Each test step initialises it's own name

  3676 	iTestStepName = _L("MM-MMF-ACOD-U-0051-HP");

  3677 	}

  3679 /** @xxxx

  3680  * PCM16 To PCMU16B Instantiate codec by UID

  3681  * @test Req. under test REQ172.6.1

  3682  */

  3683 TVerdict CTest_MMF_ACOD_U_0051::DoTestStepL()

  3684 	{

  3685 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

  3686 	TBool testOK = EFalse;

  3687 	TRAPD(err, testOK = TestNewL(codecUid));

  3689 	if (err)

  3690 		{

  3691 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3692 		return EFail;

  3693 		}

  3694 	else if (!testOK)

  3695 		{

  3696 		INFO_PRINTF1(_L("Test failed"));

  3697 		return EFail;

  3698 		}

  3699 	else

  3700 		return EPass;

  3701 	}

  3703 //------------------------------------------------------------------

  3705 /** @xxxx

  3706  * Constructor

  3707  */

  3708 CTest_MMF_ACOD_U_0052::CTest_MMF_ACOD_U_0052()

  3709 	{

  3710 	// store the name of this test case

  3711 	// this is the name that is used by the script file

  3712 	// Each test step initialises it's own name

  3713 	iTestStepName = _L("MM-MMF-ACOD-U-0052-HP");

  3715 	for (TUint i=0; i<5; i++)

  3716 		{

  3717 		iExpectedSrcBytesProcessed[i] = 50;

  3718 		iExpectedDstBytesAdded[i] = 50;

  3719 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  3720 		}

  3721 	}

  3723 /** @xxxx

  3724  * PCM16 To PCMU16B Pass in small source buffers

  3725  * @test Req. under test REQ172.6.4, REQ172.6.5

  3726  */

  3727 TVerdict CTest_MMF_ACOD_U_0052::DoTestStepL()

  3728 	{

  3729 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

  3730 	TBool testOK = EFalse;

  3731 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM16ToPCMU16BOptimumDst));

  3733 	if (err)

  3734 		{

  3735 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3736 		return EFail;

  3737 		}

  3738 	else if (!testOK)

  3739 		{

  3740 		INFO_PRINTF1(_L("Test failed"));

  3741 		return EFail;

  3742 		}

  3743 	else

  3744 		return EPass;

  3745 	}

  3747 //------------------------------------------------------------------

  3749 /** @xxxx

  3750  * Constructor

  3751  */

  3752 CTest_MMF_ACOD_U_0053::CTest_MMF_ACOD_U_0053()

  3753 	{

  3754 	// store the name of this test case

  3755 	// this is the name that is used by the script file

  3756 	// Each test step initialises it's own name

  3757 	iTestStepName = _L("MM-MMF-ACOD-U-0053-HP");

  3759 	for (TUint i=0; i<5; i++)

  3760 		{

  3761 		iExpectedSrcBytesProcessed[i] = 50;

  3762 		iExpectedDstBytesAdded[i] = 50;

  3763 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  3764 		}

  3765 	}

  3767 /** @xxxx

  3768  * PCM16 To PCMU16B Pass in small dest buffers

  3769  * @test Req. under test REQ172.6.4, REQ172.6.5

  3770  */

  3771 TVerdict CTest_MMF_ACOD_U_0053::DoTestStepL()

  3772 	{

  3773 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

  3774 	TBool testOK = EFalse;

  3775 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCMU16BOptimumSrc, KSmallBufferSize));

  3777 	if (err)

  3778 		{

  3779 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3780 		return EFail;

  3781 		}

  3782 	else if (!testOK)

  3783 		{

  3784 		INFO_PRINTF1(_L("Test failed"));

  3785 		return EFail;

  3786 		}

  3787 	else

  3788 		return EPass;

  3789 	}

  3791 //------------------------------------------------------------------

  3793 /** @xxxx

  3794  * Constructor

  3795  */

  3796 CTest_MMF_ACOD_U_0054::CTest_MMF_ACOD_U_0054()

  3797 	{

  3798 	// store the name of this test case

  3799 	// this is the name that is used by the script file

  3800 	// Each test step initialises it's own name

  3801 	iTestStepName = _L("MM-MMF-ACOD-U-0054-HP");

  3802 	iHeapSize = 0x20000;

  3803 	for (TUint i=0; i<5; i++)

  3804 		{

  3805 		iExpectedSrcBytesProcessed[i] = 10000;

  3806 		iExpectedDstBytesAdded[i] = 10000;

  3807 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3808 		}

  3809 	}

  3811 /** @xxxx

  3812  * PCM16 To PCMU16B Pass in large buffers

  3813  * @test Req. under test REQ172.6.4, REQ172.6.5

  3814  */

  3815 TVerdict CTest_MMF_ACOD_U_0054::DoTestStepL()

  3816 	{

  3817 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

  3818 	TBool testOK = EFalse;

  3819 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  3821 	if (err)

  3822 		{

  3823 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3824 		return EFail;

  3825 		}

  3826 	else if (!testOK)

  3827 		{

  3828 		INFO_PRINTF1(_L("Test failed"));

  3829 		return EFail;

  3830 		}

  3831 	else

  3832 		return EPass;

  3833 	}

  3835 //------------------------------------------------------------------

  3837 /** @xxxx

  3838  * Constructor

  3839  */

  3840 CTest_MMF_ACOD_U_0055::CTest_MMF_ACOD_U_0055()

  3841 	{

  3842 	// store the name of this test case

  3843 	// this is the name that is used by the script file

  3844 	// Each test step initialises it's own name

  3845 	iTestStepName = _L("MM-MMF-ACOD-U-0055-HP");

  3847 	for (TUint i=0; i<5; i++)

  3848 		{

  3849 		iExpectedSrcBytesProcessed[i] = 0x1000;

  3850 		iExpectedDstBytesAdded[i] = 0x1000;

  3851 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3852 		}

  3853 	}

  3855 /** @xxxx

  3856  * PCM16 To PCMU16B Pass in default sized buffers

  3857  * @test Req. under test REQ172.6.4, REQ172.6.5

  3858  */

  3859 TVerdict CTest_MMF_ACOD_U_0055::DoTestStepL()

  3860 	{

  3861 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

  3862 	TBool testOK = EFalse;

  3863 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  3865 	if (err)

  3866 		{

  3867 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3868 		return EFail;

  3869 		}

  3870 	else if (!testOK)

  3871 		{

  3872 		INFO_PRINTF1(_L("Test failed"));

  3873 		return EFail;

  3874 		}

  3875 	else

  3876 		return EPass;

  3877 	}

  3879 //------------------------------------------------------------------

  3881 /** @xxxx

  3882  * Constructor

  3883  */

  3884 CTest_MMF_ACOD_U_0056::CTest_MMF_ACOD_U_0056()

  3885 	{

  3886 	// store the name of this test case

  3887 	// this is the name that is used by the script file

  3888 	// Each test step initialises it's own name

  3889 	iTestStepName = _L("MM-MMF-ACOD-U-0056-HP");

  3891 	for (TUint i=0; i<5; i++)

  3892 		{

  3893 		iExpectedSrcBytesProcessed[i] = 0x1000;

  3894 		iExpectedDstBytesAdded[i] = 0x1000;

  3895 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3896 		}

  3897 	}

  3899 /** @xxxx

  3900  * PCM16 To PCMU16B Pass in buffers with different max length and length

  3901  * @test Req. under test REQ172.6.4, REQ172.6.5

  3902  */

  3903 TVerdict CTest_MMF_ACOD_U_0056::DoTestStepL()

  3904 	{

  3905 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

  3906 	TBool testOK = EFalse;

  3907 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  3909 	if (err)

  3910 		{

  3911 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3912 		return EFail;

  3913 		}

  3914 	else if (!testOK)

  3915 		{

  3916 		INFO_PRINTF1(_L("Test failed"));

  3917 		return EFail;

  3918 		}

  3919 	else

  3920 		return EPass;

  3921 	}

  3923 //------------------------------------------------------------------

  3925 /** @xxxx

  3926  * Constructor

  3927  */

  3928 CTest_MMF_ACOD_U_0057::CTest_MMF_ACOD_U_0057()

  3929 	{

  3930 	// store the name of this test case

  3931 	// this is the name that is used by the script file

  3932 	// Each test step initialises it's own name

  3933 	iTestStepName = _L("MM-MMF-ACOD-U-0057-HP");

  3935 	for (TUint i=0; i<5; i++)

  3936 		{

  3937 		iExpectedSrcBytesProcessed[i] = 0x1000;

  3938 		iExpectedDstBytesAdded[i] = 0x1000;

  3939 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  3940 		}

  3941 	}

  3943 /** @xxxx

  3944  * PCM16 To PCMU16B Pass in buffers of optimum size

  3945  * @test Req. under test REQ172.6.4, REQ172.6.5

  3946  */

  3947 TVerdict CTest_MMF_ACOD_U_0057::DoTestStepL()

  3948 	{

  3949 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

  3950 	TBool testOK = EFalse;

  3951 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCMU16BOptimumSrc, KPCM16ToPCMU16BOptimumDst));

  3953 	if (err)

  3954 		{

  3955 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3956 		return EFail;

  3957 		}

  3958 	else if (!testOK)

  3959 		{

  3960 		INFO_PRINTF1(_L("Test failed"));

  3961 		return EFail;

  3962 		}

  3963 	else

  3964 		return EPass;

  3965 	}

  3967 //------------------------------------------------------------------

  3969 /** @xxxx

  3970  * Constructor

  3971  */

  3972 CTest_MMF_ACOD_U_0058::CTest_MMF_ACOD_U_0058()

  3973 	{

  3974 	// store the name of this test case

  3975 	// this is the name that is used by the script file

  3976 	// Each test step initialises it's own name

  3977 	iTestStepName = _L("MM-MMF-ACOD-U-0058-HP");

  3978 	}

  3980 /** @xxxx

  3981  * PCM16 To PCMU16B Reposition source pointer during conversion

  3982  * @test Req. under test REQ172.11

  3983  */

  3984 TVerdict CTest_MMF_ACOD_U_0058::DoTestStepL()

  3985 	{

  3986 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

  3987 	TBool testOK = EFalse;

  3989 	INFO_PRINTF1(_L(">> The PCM16 to PCMU16B codec doesn't currently store data between calls to ProcessL"));

  3990 	TRAPD(err, testOK = TestRepositionL(codecUid, KDefaultBufferSize, KDefaultBufferSize+30));

  3992 	if (err)

  3993 		{

  3994 		INFO_PRINTF2(_L("Test left with status %d"), err);

  3995 		return EFail;

  3996 		}

  3997 	else if (!testOK)

  3998 		{

  3999 		INFO_PRINTF1(_L("Test failed"));

  4000 		return EFail;

  4001 		}

  4002 	else

  4003 		return EPass;

  4004 	}

  4006 //------------------------------------------------------------------

  4008 /** @xxxx

  4009  * Constructor

  4010  */

  4011 CTest_MMF_ACOD_U_0059::CTest_MMF_ACOD_U_0059()

  4012 	{

  4013 	// store the name of this test case

  4014 	// this is the name that is used by the script file

  4015 	// Each test step initialises it's own name

  4016 	iTestStepName = _L("MM-MMF-ACOD-U-0059-HP");

  4017 	}

  4019 /** @xxxx

  4020  * PCM16 To PCMU16 Instantiate codec by FourCC Codes

  4021  * @test Req. under test REQ172.6.2, REQ172.11.7

  4022  */

  4023 TVerdict CTest_MMF_ACOD_U_0059::DoTestStepL()

  4024 	{

  4025 	TBool testOK = EFalse;

  4026 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodePCMU16));

  4028 	if (err)

  4029 		{

  4030 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4031 		return EFail;

  4032 		}

  4033 	else if (!testOK)

  4034 		{

  4035 		INFO_PRINTF1(_L("Test failed"));

  4036 		return EFail;

  4037 		}

  4038 	else

  4039 		return EPass;

  4040 	}

  4042 //------------------------------------------------------------------

  4044 /** @xxxx

  4045  * Constructor

  4046  */

  4047 CTest_MMF_ACOD_U_0060::CTest_MMF_ACOD_U_0060()

  4048 	{

  4049 	// store the name of this test case

  4050 	// this is the name that is used by the script file

  4051 	// Each test step initialises it's own name

  4052 	iTestStepName = _L("MM-MMF-ACOD-U-0060-HP");

  4053 	}

  4055 /** @xxxx

  4056  * PCM16 To PCMU16 Instantiate codec by UID

  4057  * @test Req. under test REQ172.6.1, REQ172.11.7

  4058  */

  4059 TVerdict CTest_MMF_ACOD_U_0060::DoTestStepL()

  4060 	{

  4061 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

  4062 	TBool testOK = EFalse;

  4063 	TRAPD(err, testOK = TestNewL(codecUid));

  4065 	if (err)

  4066 		{

  4067 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4068 		return EFail;

  4069 		}

  4070 	else if (!testOK)

  4071 		{

  4072 		INFO_PRINTF1(_L("Test failed"));

  4073 		return EFail;

  4074 		}

  4075 	else

  4076 		return EPass;

  4077 	}

  4079 //------------------------------------------------------------------

  4081 /** @xxxx

  4082  * Constructor

  4083  */

  4084 CTest_MMF_ACOD_U_0061::CTest_MMF_ACOD_U_0061()

  4085 	{

  4086 	// store the name of this test case

  4087 	// this is the name that is used by the script file

  4088 	// Each test step initialises it's own name

  4089 	iTestStepName = _L("MM-MMF-ACOD-U-0061-HP");

  4091 	for (TUint i=0; i<5; i++)

  4092 		{

  4093 		iExpectedSrcBytesProcessed[i] = 50;

  4094 		iExpectedDstBytesAdded[i] = 50;

  4095 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  4096 		}

  4097 	}

  4099 /** @xxxx

  4100  * PCM16 To PCMU16 Pass in small source buffers

  4101  * @test Req. under test REQ172.6.4, REQ172.6.5

  4102  */

  4103 TVerdict CTest_MMF_ACOD_U_0061::DoTestStepL()

  4104 	{

  4105 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

  4106 	TBool testOK = EFalse;

  4107 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM16ToPCMU16OptimumDst));

  4109 	if (err)

  4110 		{

  4111 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4112 		return EFail;

  4113 		}

  4114 	else if (!testOK)

  4115 		{

  4116 		INFO_PRINTF1(_L("Test failed"));

  4117 		return EFail;

  4118 		}

  4119 	else

  4120 		return EPass;

  4121 	}

  4123 //------------------------------------------------------------------

  4125 /** @xxxx

  4126  * Constructor

  4127  */

  4128 CTest_MMF_ACOD_U_0062::CTest_MMF_ACOD_U_0062()

  4129 	{

  4130 	// store the name of this test case

  4131 	// this is the name that is used by the script file

  4132 	// Each test step initialises it's own name

  4133 	iTestStepName = _L("MM-MMF-ACOD-U-0062-HP");

  4135 	for (TUint i=0; i<5; i++)

  4136 		{

  4137 		iExpectedSrcBytesProcessed[i] = 50;

  4138 		iExpectedDstBytesAdded[i] = 50;

  4139 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  4140 		}

  4141 	}

  4143 /** @xxxx

  4144  * PCM16 To PCMU16 Pass in small dest buffers

  4145  * @test Req. under test REQ172.6.4, REQ172.6.5

  4146  */

  4147 TVerdict CTest_MMF_ACOD_U_0062::DoTestStepL()

  4148 	{

  4149 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

  4150 	TBool testOK = EFalse;

  4151 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCMU16OptimumSrc, KSmallBufferSize));

  4153 	if (err)

  4154 		{

  4155 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4156 		return EFail;

  4157 		}

  4158 	else if (!testOK)

  4159 		{

  4160 		INFO_PRINTF1(_L("Test failed"));

  4161 		return EFail;

  4162 		}

  4163 	else

  4164 		return EPass;

  4165 	}

  4167 //------------------------------------------------------------------

  4169 /** @xxxx

  4170  * Constructor

  4171  */

  4172 CTest_MMF_ACOD_U_0063::CTest_MMF_ACOD_U_0063()

  4173 	{

  4174 	// store the name of this test case

  4175 	// this is the name that is used by the script file

  4176 	// Each test step initialises it's own name

  4177 	iTestStepName = _L("MM-MMF-ACOD-U-0063-HP");

  4178 	iHeapSize = 0x20000;

  4180 	for (TUint i=0; i<5; i++)

  4181 		{

  4182 		iExpectedSrcBytesProcessed[i] = 10000;

  4183 		iExpectedDstBytesAdded[i] = 10000;

  4184 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4185 		}

  4186 	}

  4188 /** @xxxx

  4189  * PCM16 To PCMU16 Pass in large buffers

  4190  * @test Req. under test REQ172.6.4, REQ172.6.5

  4191  */

  4192 TVerdict CTest_MMF_ACOD_U_0063::DoTestStepL()

  4193 	{

  4194 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

  4195 	TBool testOK = EFalse;

  4196 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  4198 	if (err)

  4199 		{

  4200 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4201 		return EFail;

  4202 		}

  4203 	else if (!testOK)

  4204 		{

  4205 		INFO_PRINTF1(_L("Test failed"));

  4206 		return EFail;

  4207 		}

  4208 	else

  4209 		return EPass;

  4210 	}

  4212 //------------------------------------------------------------------

  4214 /** @xxxx

  4215  * Constructor

  4216  */

  4217 CTest_MMF_ACOD_U_0064::CTest_MMF_ACOD_U_0064()

  4218 	{

  4219 	// store the name of this test case

  4220 	// this is the name that is used by the script file

  4221 	// Each test step initialises it's own name

  4222 	iTestStepName = _L("MM-MMF-ACOD-U-0064-HP");

  4224 	for (TUint i=0; i<5; i++)

  4225 		{

  4226 		iExpectedSrcBytesProcessed[i] = 0x1000;

  4227 		iExpectedDstBytesAdded[i] = 0x1000;

  4228 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4229 		}

  4230 	}

  4232 /** @xxxx

  4233  * PCM16 To PCMU16 Pass in default sized buffers

  4234  * @test Req. under test REQ172.6.4, REQ172.6.5

  4235  */

  4236 TVerdict CTest_MMF_ACOD_U_0064::DoTestStepL()

  4237 	{

  4238 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

  4239 	TBool testOK = EFalse;

  4240 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  4242 	if (err)

  4243 		{

  4244 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4245 		return EFail;

  4246 		}

  4247 	else if (!testOK)

  4248 		{

  4249 		INFO_PRINTF1(_L("Test failed"));

  4250 		return EFail;

  4251 		}

  4252 	else

  4253 		return EPass;

  4254 	}

  4256 //------------------------------------------------------------------

  4258 /** @xxxx

  4259  * Constructor

  4260  */

  4261 CTest_MMF_ACOD_U_0065::CTest_MMF_ACOD_U_0065()

  4262 	{

  4263 	// store the name of this test case

  4264 	// this is the name that is used by the script file

  4265 	// Each test step initialises it's own name

  4266 	iTestStepName = _L("MM-MMF-ACOD-U-0065-HP");

  4268 	for (TUint i=0; i<5; i++)

  4269 		{

  4270 		iExpectedSrcBytesProcessed[i] = 0x1000;

  4271 		iExpectedDstBytesAdded[i] = 0x1000;

  4272 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4273 		}

  4274 	}

  4276 /** @xxxx

  4277  * PCM16 To PCMU16 Pass in buffers with different max length and length

  4278  * @test Req. under test REQ172.6.4, REQ172.6.5

  4279  */

  4280 TVerdict CTest_MMF_ACOD_U_0065::DoTestStepL()

  4281 	{

  4282 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

  4283 	TBool testOK = EFalse;

  4284 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  4286 	if (err)

  4287 		{

  4288 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4289 		return EFail;

  4290 		}

  4291 	else if (!testOK)

  4292 		{

  4293 		INFO_PRINTF1(_L("Test failed"));

  4294 		return EFail;

  4295 		}

  4296 	else

  4297 		return EPass;

  4298 	}

  4300 //------------------------------------------------------------------

  4302 /** @xxxx

  4303  * Constructor

  4304  */

  4305 CTest_MMF_ACOD_U_0066::CTest_MMF_ACOD_U_0066()

  4306 	{

  4307 	// store the name of this test case

  4308 	// this is the name that is used by the script file

  4309 	// Each test step initialises it's own name

  4310 	iTestStepName = _L("MM-MMF-ACOD-U-0066-HP");

  4312 	for (TUint i=0; i<5; i++)

  4313 		{

  4314 		iExpectedSrcBytesProcessed[i] = 0x1000;

  4315 		iExpectedDstBytesAdded[i] = 0x1000;

  4316 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4317 		}

  4318 	}

  4320 /** @xxxx

  4321  * PCM16 To PCMU16 Pass in buffers of optimum size

  4322  * @test Req. under test REQ172.6.4, REQ172.6.5

  4323  */

  4324 TVerdict CTest_MMF_ACOD_U_0066::DoTestStepL()

  4325 	{

  4326 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

  4327 	TBool testOK = EFalse;

  4328 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCMU16OptimumSrc, KPCM16ToPCMU16OptimumDst));

  4330 	if (err)

  4331 		{

  4332 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4333 		return EFail;

  4334 		}

  4335 	else if (!testOK)

  4336 		{

  4337 		INFO_PRINTF1(_L("Test failed"));

  4338 		return EFail;

  4339 		}

  4340 	else

  4341 		return EPass;

  4342 	}

  4344 //------------------------------------------------------------------

  4346 /** @xxxx

  4347  * Constructor

  4348  */

  4349 CTest_MMF_ACOD_U_0067::CTest_MMF_ACOD_U_0067()

  4350 	{

  4351 	// store the name of this test case

  4352 	// this is the name that is used by the script file

  4353 	// Each test step initialises it's own name

  4354 	iTestStepName = _L("MM-MMF-ACOD-U-0067-HP");

  4355 	}

  4357 /** @xxxx

  4358  * PCM16 To PCMU16 Reposition source pointer during conversion

  4359  * @test Req. under test REQ172.11

  4360  */

  4361 TVerdict CTest_MMF_ACOD_U_0067::DoTestStepL()

  4362 	{

  4363 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

  4364 	TBool testOK = EFalse;

  4366 	INFO_PRINTF1(_L(">> The PCM16 to PCMU16 codec doesn't currently store data between calls to ProcessL"));

  4367 	TRAPD(err, testOK = TestRepositionL(codecUid, KDefaultBufferSize, KDefaultBufferSize+30));

  4369 	if (err)

  4370 		{

  4371 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4372 		return EFail;

  4373 		}

  4374 	else if (!testOK)

  4375 		{

  4376 		INFO_PRINTF1(_L("Test failed"));

  4377 		return EFail;

  4378 		}

  4379 	else

  4380 		return EPass;

  4381 	}

  4383 //------------------------------------------------------------------

  4385 /** @xxxx

  4386  * Constructor

  4387  */

  4388 CTest_MMF_ACOD_U_0068::CTest_MMF_ACOD_U_0068()

  4389 	{

  4390 	// store the name of this test case

  4391 	// this is the name that is used by the script file

  4392 	// Each test step initialises it's own name

  4393 	iTestStepName = _L("MM-MMF-ACOD-U-0068-HP");

  4394 	}

  4396 /** @xxxx

  4397  * PCM16 To PCMU8 Instantiate codec by FourCC Codes

  4398  * @test Req. under test REQ172.6.2, REQ172.11.8

  4399  */

  4400 TVerdict CTest_MMF_ACOD_U_0068::DoTestStepL()

  4401 	{

  4402 	TBool testOK = EFalse;

  4403 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodePCMU8));

  4405 	if (err)

  4406 		{

  4407 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4408 		return EFail;

  4409 		}

  4410 	else if (!testOK)

  4411 		{

  4412 		INFO_PRINTF1(_L("Test failed"));

  4413 		return EFail;

  4414 		}

  4415 	else

  4416 		return EPass;

  4417 	}

  4419 //------------------------------------------------------------------

  4421 /** @xxxx

  4422  * Constructor

  4423  */

  4424 CTest_MMF_ACOD_U_0069::CTest_MMF_ACOD_U_0069()

  4425 	{

  4426 	// store the name of this test case

  4427 	// this is the name that is used by the script file

  4428 	// Each test step initialises it's own name

  4429 	iTestStepName = _L("MM-MMF-ACOD-U-0069-HP");

  4430 	}

  4432 /** @xxxx

  4433  * PCM16 To PCMU8 Instantiate codec by UID

  4434  * @test Req. under test REQ172.6.1, REQ172.11.8

  4435  */

  4436 TVerdict CTest_MMF_ACOD_U_0069::DoTestStepL()

  4437 	{

  4438 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

  4439 	TBool testOK = EFalse;

  4440 	TRAPD(err, testOK = TestNewL(codecUid));

  4442 	if (err)

  4443 		{

  4444 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4445 		return EFail;

  4446 		}

  4447 	else if (!testOK)

  4448 		{

  4449 		INFO_PRINTF1(_L("Test failed"));

  4450 		return EFail;

  4451 		}

  4452 	else

  4453 		return EPass;

  4454 	}

  4456 //------------------------------------------------------------------

  4458 /** @xxxx

  4459  * Constructor

  4460  */

  4461 CTest_MMF_ACOD_U_0070::CTest_MMF_ACOD_U_0070()

  4462 	{

  4463 	// store the name of this test case

  4464 	// this is the name that is used by the script file

  4465 	// Each test step initialises it's own name

  4466 	iTestStepName = _L("MM-MMF-ACOD-U-0070-HP");

  4468 	for (TUint i=0; i<5; i++)

  4469 		{

  4470 		iExpectedSrcBytesProcessed[i] = 50;

  4471 		iExpectedDstBytesAdded[i] = 25;

  4472 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  4473 		}

  4474 	}

  4476 /** @xxxx

  4477  * PCM16 To PCMU8 Pass in small source buffers

  4478  * @test Req. under test REQ172.6.4, REQ172.6.5

  4479  */

  4480 TVerdict CTest_MMF_ACOD_U_0070::DoTestStepL()

  4481 	{

  4482 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

  4483 	TBool testOK = EFalse;

  4484 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM16ToPCMU8OptimumDst));

  4486 	if (err)

  4487 		{

  4488 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4489 		return EFail;

  4490 		}

  4491 	else if (!testOK)

  4492 		{

  4493 		INFO_PRINTF1(_L("Test failed"));

  4494 		return EFail;

  4495 		}

  4496 	else

  4497 		return EPass;

  4498 	}

  4500 //------------------------------------------------------------------

  4502 /** @xxxx

  4503  * Constructor

  4504  */

  4505 CTest_MMF_ACOD_U_0071::CTest_MMF_ACOD_U_0071()

  4506 	{

  4507 	// store the name of this test case

  4508 	// this is the name that is used by the script file

  4509 	// Each test step initialises it's own name

  4510 	iTestStepName = _L("MM-MMF-ACOD-U-0071-HP");

  4512 	for (TUint i=0; i<5; i++)

  4513 		{

  4514 		iExpectedSrcBytesProcessed[i] = 100;

  4515 		iExpectedDstBytesAdded[i] = 50;

  4516 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  4517 		}

  4518 	}

  4520 /** @xxxx

  4521  * PCM16 To PCMU8 Pass in small dest buffers

  4522  * @test Req. under test REQ172.6.4, REQ172.6.5

  4523  */

  4524 TVerdict CTest_MMF_ACOD_U_0071::DoTestStepL()

  4525 	{

  4526 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

  4527 	TBool testOK = EFalse;

  4528 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCMU8OptimumSrc, KSmallBufferSize));

  4530 	if (err)

  4531 		{

  4532 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4533 		return EFail;

  4534 		}

  4535 	else if (!testOK)

  4536 		{

  4537 		INFO_PRINTF1(_L("Test failed"));

  4538 		return EFail;

  4539 		}

  4540 	else

  4541 		return EPass;

  4542 	}

  4544 //------------------------------------------------------------------

  4546 /** @xxxx

  4547  * Constructor

  4548  */

  4549 CTest_MMF_ACOD_U_0072::CTest_MMF_ACOD_U_0072()

  4550 	{

  4551 	// store the name of this test case

  4552 	// this is the name that is used by the script file

  4553 	// Each test step initialises it's own name

  4554 	iTestStepName = _L("MM-MMF-ACOD-U-0072-HP");

  4555 	iHeapSize = 0x20000;

  4557 	for (TUint i=0; i<5; i++)

  4558 		{

  4559 		iExpectedSrcBytesProcessed[i] = 10000;

  4560 		iExpectedDstBytesAdded[i] = 5000;

  4562 		if((i%2)==0)//even i

  4563 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  4564 		else		//odd i

  4565 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4566 		}

  4567 	}

  4569 /** @xxxx

  4570  * PCM16 To PCMU8 Pass in large buffers

  4571  * @test Req. under test REQ172.6.4, REQ172.6.5

  4572  */

  4573 TVerdict CTest_MMF_ACOD_U_0072::DoTestStepL()

  4574 	{

  4575 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

  4576 	TBool testOK = EFalse;

  4577 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  4579 	if (err)

  4580 		{

  4581 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4582 		return EFail;

  4583 		}

  4584 	else if (!testOK)

  4585 		{

  4586 		INFO_PRINTF1(_L("Test failed"));

  4587 		return EFail;

  4588 		}

  4589 	else

  4590 		return EPass;

  4591 	}

  4593 //------------------------------------------------------------------

  4595 /** @xxxx

  4596  * Constructor

  4597  */

  4598 CTest_MMF_ACOD_U_0073::CTest_MMF_ACOD_U_0073()

  4599 	{

  4600 	// store the name of this test case

  4601 	// this is the name that is used by the script file

  4602 	// Each test step initialises it's own name

  4603 	iTestStepName = _L("MM-MMF-ACOD-U-0073-HP");

  4605 	for (TUint i=0; i<5; i++)

  4606 		{

  4607 		iExpectedSrcBytesProcessed[i] = 0x1000;

  4608 		iExpectedDstBytesAdded[i] = 0x800;

  4610 		if((i%2)==0)//even i

  4611 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  4612 		else		//odd i

  4613 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4614 		}

  4615 	}

  4617 /** @xxxx

  4618  * PCM16 To PCMU8 Pass in default sized buffers

  4619  * @test Req. under test REQ172.6.4, REQ172.6.5

  4620  */

  4621 TVerdict CTest_MMF_ACOD_U_0073::DoTestStepL()

  4622 	{

  4623 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

  4624 	TBool testOK = EFalse;

  4625 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  4627 	if (err)

  4628 		{

  4629 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4630 		return EFail;

  4631 		}

  4632 	else if (!testOK)

  4633 		{

  4634 		INFO_PRINTF1(_L("Test failed"));

  4635 		return EFail;

  4636 		}

  4637 	else

  4638 		return EPass;

  4639 	}

  4641 //------------------------------------------------------------------

  4643 /** @xxxx

  4644  * Constructor

  4645  */

  4646 CTest_MMF_ACOD_U_0074::CTest_MMF_ACOD_U_0074()

  4647 	{

  4648 	// store the name of this test case

  4649 	// this is the name that is used by the script file

  4650 	// Each test step initialises it's own name

  4651 	iTestStepName = _L("MM-MMF-ACOD-U-0074-HP");

  4653 	for (TUint i=0; i<5; i++)

  4654 		{

  4655 		iExpectedSrcBytesProcessed[i] = 0x1000;

  4656 		iExpectedDstBytesAdded[i] = 0x800;

  4658 		if((i%2)==0)//even i

  4659 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  4660 		else		//odd i

  4661 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4662 		}

  4663 	}

  4665 /** @xxxx

  4666  * PCM16 To PCMU8 Pass in buffers with different max length and length

  4667  * @test Req. under test REQ172.6.4, REQ172.6.5

  4668  */

  4669 TVerdict CTest_MMF_ACOD_U_0074::DoTestStepL()

  4670 	{

  4671 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

  4672 	TBool testOK = EFalse;

  4673 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  4675 	if (err)

  4676 		{

  4677 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4678 		return EFail;

  4679 		}

  4680 	else if (!testOK)

  4681 		{

  4682 		INFO_PRINTF1(_L("Test failed"));

  4683 		return EFail;

  4684 		}

  4685 	else

  4686 		return EPass;

  4687 	}

  4689 //------------------------------------------------------------------

  4691 /** @xxxx

  4692  * Constructor

  4693  */

  4694 CTest_MMF_ACOD_U_0075::CTest_MMF_ACOD_U_0075()

  4695 	{

  4696 	// store the name of this test case

  4697 	// this is the name that is used by the script file

  4698 	// Each test step initialises it's own name

  4699 	iTestStepName = _L("MM-MMF-ACOD-U-0075-HP");

  4701 	for (TUint i=0; i<5; i++)

  4702 		{

  4703 		iExpectedSrcBytesProcessed[i] = 0x1000;

  4704 		iExpectedDstBytesAdded[i] = 0x800;

  4705 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4706 		}

  4707 	}

  4709 /** @xxxx

  4710  * PCM16 To PCMU8 Pass in buffers of optimum size

  4711  * @test Req. under test REQ172.6.4, REQ172.6.5

  4712  */

  4713 TVerdict CTest_MMF_ACOD_U_0075::DoTestStepL()

  4714 	{

  4715 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

  4716 	TBool testOK = EFalse;

  4717 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCMU8OptimumSrc, KPCM16ToPCMU8OptimumDst));

  4719 	if (err)

  4720 		{

  4721 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4722 		return EFail;

  4723 		}

  4724 	else if (!testOK)

  4725 		{

  4726 		INFO_PRINTF1(_L("Test failed"));

  4727 		return EFail;

  4728 		}

  4729 	else

  4730 		return EPass;

  4731 	}

  4733 //------------------------------------------------------------------

  4735 /** @xxxx

  4736  * Constructor

  4737  */

  4738 CTest_MMF_ACOD_U_0076::CTest_MMF_ACOD_U_0076()

  4739 	{

  4740 	// store the name of this test case

  4741 	// this is the name that is used by the script file

  4742 	// Each test step initialises it's own name

  4743 	iTestStepName = _L("MM-MMF-ACOD-U-0076-HP");

  4744 	}

  4746 /** @xxxx

  4747  * PCM16 To PCMU8 Reposition source pointer during conversion

  4748  * @test Req. under test REQ172.11

  4749  */

  4750 TVerdict CTest_MMF_ACOD_U_0076::DoTestStepL()

  4751 	{

  4752 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

  4753 	TBool testOK = EFalse;

  4755 	INFO_PRINTF1(_L(">> The PCM16 to PCMU8 codec doesn't currently store data between calls to ProcessL"));

  4756 	TRAPD(err, testOK = TestRepositionL(codecUid, KDefaultBufferSize, KDefaultBufferSize+30));

  4758 	if (err)

  4759 		{

  4760 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4761 		return EFail;

  4762 		}

  4763 	else if (!testOK)

  4764 		{

  4765 		INFO_PRINTF1(_L("Test failed"));

  4766 		return EFail;

  4767 		}

  4768 	else

  4769 		return EPass;

  4770 	}

  4772 //-----------------------------------------------------------------

  4774 /** @xxxx

  4775  * Constructor

  4776  */

  4777 CTest_MMF_ACOD_U_0077::CTest_MMF_ACOD_U_0077()

  4778 	{

  4779 	// store the name of this test case

  4780 	// this is the name that is used by the script file

  4781 	// Each test step initialises it's own name

  4782 	iTestStepName = _L("MM-MMF-ACOD-U-0077-HP");

  4783 	}

  4785 /** @xxxx

  4786  * PCMU16B To PCM16 Instantiate codec by FourCC Codes

  4787  * @test Req. under test REQ172.6.2, REQ172.11.9

  4788  */

  4789 TVerdict CTest_MMF_ACOD_U_0077::DoTestStepL()

  4790 	{

  4791 	TBool testOK = EFalse;

  4792 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCMU16B, KMMFFourCCCodePCM16));

  4794 	if (err)

  4795 		{

  4796 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4797 		return EFail;

  4798 		}

  4799 	else if (!testOK)

  4800 		{

  4801 		INFO_PRINTF1(_L("Test failed"));

  4802 		return EFail;

  4803 		}

  4804 	else

  4805 		return EPass;

  4806 	}

  4808 //------------------------------------------------------------------

  4810 /** @xxxx

  4811  * Constructor

  4812  */

  4813 CTest_MMF_ACOD_U_0078::CTest_MMF_ACOD_U_0078()

  4814 	{

  4815 	// store the name of this test case

  4816 	// this is the name that is used by the script file

  4817 	// Each test step initialises it's own name

  4818 	iTestStepName = _L("MM-MMF-ACOD-U-0078-HP");

  4819 	}

  4821 /** @xxxx

  4822  * PCMU16B To PCM16 Instantiate codec by UID

  4823  * @test Req. under test REQ172.6.1, REQ172.11.9

  4824  */

  4825 TVerdict CTest_MMF_ACOD_U_0078::DoTestStepL()

  4826 	{

  4827 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

  4828 	TBool testOK = EFalse;

  4829 	TRAPD(err, testOK = TestNewL(codecUid));

  4831 	if (err)

  4832 		{

  4833 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4834 		return EFail;

  4835 		}

  4836 	else if (!testOK)

  4837 		{

  4838 		INFO_PRINTF1(_L("Test failed"));

  4839 		return EFail;

  4840 		}

  4841 	else

  4842 		return EPass;

  4843 	}

  4845 //------------------------------------------------------------------

  4847 /** @xxxx

  4848  * Constructor

  4849  */

  4850 CTest_MMF_ACOD_U_0079::CTest_MMF_ACOD_U_0079()

  4851 	{

  4852 	// store the name of this test case

  4853 	// this is the name that is used by the script file

  4854 	// Each test step initialises it's own name

  4855 	iTestStepName = _L("MM-MMF-ACOD-U-0079-HP");

  4857 	for (TUint i=0; i<5; i++)

  4858 		{

  4859 		iExpectedSrcBytesProcessed[i] = 50;

  4860 		iExpectedDstBytesAdded[i] = 50;

  4861 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  4862 		}

  4863 	}

  4865 /** @xxxx

  4866  * PCMU16B To PCM16 Pass in small source buffers

  4867  * @test Req. under test REQ172.6.4, REQ172.6.5

  4868  */

  4869 TVerdict CTest_MMF_ACOD_U_0079::DoTestStepL()

  4870 	{

  4871 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

  4872 	TBool testOK = EFalse;

  4873 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCMU16BToPCM16OptimumDst));

  4875 	if (err)

  4876 		{

  4877 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4878 		return EFail;

  4879 		}

  4880 	else if (!testOK)

  4881 		{

  4882 		INFO_PRINTF1(_L("Test failed"));

  4883 		return EFail;

  4884 		}

  4885 	else

  4886 		return EPass;

  4887 	}

  4889 //------------------------------------------------------------------

  4891 /** @xxxx

  4892  * Constructor

  4893  */

  4894 CTest_MMF_ACOD_U_0080::CTest_MMF_ACOD_U_0080()

  4895 	{

  4896 	// store the name of this test case

  4897 	// this is the name that is used by the script file

  4898 	// Each test step initialises it's own name

  4899 	iTestStepName = _L("MM-MMF-ACOD-U-0080-HP");

  4901 	for (TUint i=0; i<5; i++)

  4902 		{

  4903 		iExpectedSrcBytesProcessed[i] = 50;

  4904 		iExpectedDstBytesAdded[i] = 50;

  4905 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  4906 		}

  4907 	}

  4909 /** @xxxx

  4910  * PCMU16B To PCM16 Pass in small dest buffers

  4911  * @test Req. under test REQ172.6.4, REQ172.6.5

  4912  */

  4913 TVerdict CTest_MMF_ACOD_U_0080::DoTestStepL()

  4914 	{

  4915 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

  4916 	TBool testOK = EFalse;

  4917 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCMU16BToPCM16OptimumSrc, KSmallBufferSize));

  4919 	if (err)

  4920 		{

  4921 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4922 		return EFail;

  4923 		}

  4924 	else if (!testOK)

  4925 		{

  4926 		INFO_PRINTF1(_L("Test failed"));

  4927 		return EFail;

  4928 		}

  4929 	else

  4930 		return EPass;

  4931 	}

  4933 //------------------------------------------------------------------

  4935 /** @xxxx

  4936  * Constructor

  4937  */

  4938 CTest_MMF_ACOD_U_0081::CTest_MMF_ACOD_U_0081()

  4939 	{

  4940 	// store the name of this test case

  4941 	// this is the name that is used by the script file

  4942 	// Each test step initialises it's own name

  4943 	iTestStepName = _L("MM-MMF-ACOD-U-0081-HP");

  4944 	iHeapSize = 0x20000;

  4946 	for (TUint i=0; i<5; i++)

  4947 		{

  4948 		iExpectedSrcBytesProcessed[i] = 10000;

  4949 		iExpectedDstBytesAdded[i] = 10000;

  4950 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4951 		}

  4952 	}

  4954 /** @xxxx

  4955  * PCMU16B To PCM16 Pass in large buffers

  4956  * @test Req. under test REQ172.6.4, REQ172.6.5

  4957  */

  4958 TVerdict CTest_MMF_ACOD_U_0081::DoTestStepL()

  4959 	{

  4960 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

  4961 	TBool testOK = EFalse;

  4962 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  4964 	if (err)

  4965 		{

  4966 		INFO_PRINTF2(_L("Test left with status %d"), err);

  4967 		return EFail;

  4968 		}

  4969 	else if (!testOK)

  4970 		{

  4971 		INFO_PRINTF1(_L("Test failed"));

  4972 		return EFail;

  4973 		}

  4974 	else

  4975 		return EPass;

  4976 	}

  4978 //------------------------------------------------------------------

  4980 /** @xxxx

  4981  * Constructor

  4982  */

  4983 CTest_MMF_ACOD_U_0082::CTest_MMF_ACOD_U_0082()

  4984 	{

  4985 	// store the name of this test case

  4986 	// this is the name that is used by the script file

  4987 	// Each test step initialises it's own name

  4988 	iTestStepName = _L("MM-MMF-ACOD-U-0082-HP");

  4990 	for (TUint i=0; i<5; i++)

  4991 		{

  4992 		iExpectedSrcBytesProcessed[i] = 0x1000;

  4993 		iExpectedDstBytesAdded[i] = 0x1000;

  4994 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  4995 		}

  4996 	}

  4998 /** @xxxx

  4999  * PCMU16B To PCM16 Pass in default sized buffers

  5000  * @test Req. under test REQ172.6.4, REQ172.6.5

  5001  */

  5002 TVerdict CTest_MMF_ACOD_U_0082::DoTestStepL()

  5003 	{

  5004 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

  5005 	TBool testOK = EFalse;

  5006 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  5008 	if (err)

  5009 		{

  5010 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5011 		return EFail;

  5012 		}

  5013 	else if (!testOK)

  5014 		{

  5015 		INFO_PRINTF1(_L("Test failed"));

  5016 		return EFail;

  5017 		}

  5018 	else

  5019 		return EPass;

  5020 	}

  5022 //------------------------------------------------------------------

  5024 /** @xxxx

  5025  * Constructor

  5026  */

  5027 CTest_MMF_ACOD_U_0083::CTest_MMF_ACOD_U_0083()

  5028 	{

  5029 	// store the name of this test case

  5030 	// this is the name that is used by the script file

  5031 	// Each test step initialises it's own name

  5032 	iTestStepName = _L("MM-MMF-ACOD-U-0083-HP");

  5034 	for (TUint i=0; i<5; i++)

  5035 		{

  5036 		iExpectedSrcBytesProcessed[i] = 0x1000;

  5037 		iExpectedDstBytesAdded[i] = 0x1000;

  5038 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5039 		}

  5040 	}

  5042 /** @xxxx

  5043  * PCMU16B To PCM16 Pass in buffers with different max length and length

  5044  * @test Req. under test REQ172.6.4, REQ172.6.5

  5045  */

  5046 TVerdict CTest_MMF_ACOD_U_0083::DoTestStepL()

  5047 	{

  5048 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

  5049 	TBool testOK = EFalse;

  5050 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  5052 	if (err)

  5053 		{

  5054 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5055 		return EFail;

  5056 		}

  5057 	else if (!testOK)

  5058 		{

  5059 		INFO_PRINTF1(_L("Test failed"));

  5060 		return EFail;

  5061 		}

  5062 	else

  5063 		return EPass;

  5064 	}

  5066 //------------------------------------------------------------------

  5068 /** @xxxx

  5069  * Constructor

  5070  */

  5071 CTest_MMF_ACOD_U_0084::CTest_MMF_ACOD_U_0084()

  5072 	{

  5073 	// store the name of this test case

  5074 	// this is the name that is used by the script file

  5075 	// Each test step initialises it's own name

  5076 	iTestStepName = _L("MM-MMF-ACOD-U-0084-HP");

  5078 	for (TUint i=0; i<5; i++)

  5079 		{

  5080 		iExpectedSrcBytesProcessed[i] = 0x1000;

  5081 		iExpectedDstBytesAdded[i] = 0x1000;

  5082 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5083 		}

  5084 	}

  5086 /** @xxxx

  5087  * PCMU16B To PCM16 Pass in buffers of optimum size

  5088  * @test Req. under test REQ172.6.4, REQ172.6.5

  5089  */

  5090 TVerdict CTest_MMF_ACOD_U_0084::DoTestStepL()

  5091 	{

  5092 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

  5093 	TBool testOK = EFalse;

  5094 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCMU16BToPCM16OptimumSrc, KPCMU16BToPCM16OptimumDst));

  5096 	if (err)

  5097 		{

  5098 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5099 		return EFail;

  5100 		}

  5101 	else if (!testOK)

  5102 		{

  5103 		INFO_PRINTF1(_L("Test failed"));

  5104 		return EFail;

  5105 		}

  5106 	else

  5107 		return EPass;

  5108 	}

  5110 //------------------------------------------------------------------

  5112 /** @xxxx

  5113  * Constructor

  5114  */

  5115 CTest_MMF_ACOD_U_0085::CTest_MMF_ACOD_U_0085()

  5116 	{

  5117 	// store the name of this test case

  5118 	// this is the name that is used by the script file

  5119 	// Each test step initialises it's own name

  5120 	iTestStepName = _L("MM-MMF-ACOD-U-0085-HP");

  5121 	}

  5123 /** @xxxx

  5124  * PCMU16B To PCM16 Reposition source pointer during conversion

  5125  * @test Req. under test REQ172.11

  5126  */

  5127 TVerdict CTest_MMF_ACOD_U_0085::DoTestStepL()

  5128 	{

  5129 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

  5130 	TBool testOK = EFalse;

  5132 	INFO_PRINTF1(_L(">> The PCMU16B to PCM16 codec doesn't currently store data between calls to ProcessL"));

  5133 	TRAPD(err, testOK = TestRepositionL(codecUid, KDefaultBufferSize, KDefaultBufferSize+30));

  5135 	if (err)

  5136 		{

  5137 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5138 		return EFail;

  5139 		}

  5140 	else if (!testOK)

  5141 		{

  5142 		INFO_PRINTF1(_L("Test failed"));

  5143 		return EFail;

  5144 		}

  5145 	else

  5146 		return EPass;

  5147 	}

  5149 //------------------------------------------------------------------

  5151 /** @xxxx

  5152  * Constructor

  5153  */

  5154 CTest_MMF_ACOD_U_0086::CTest_MMF_ACOD_U_0086()

  5155 	{

  5156 	// store the name of this test case

  5157 	// this is the name that is used by the script file

  5158 	// Each test step initialises it's own name

  5159 	iTestStepName = _L("MM-MMF-ACOD-U-0086-HP");

  5160 	}

  5162 /** @xxxx

  5163  * PCMU16 To PCM16 Instantiate codec by FourCC Codes

  5164  * @test Req. under test REQ172.6.2, REQ172.11.25

  5165  */

  5166 TVerdict CTest_MMF_ACOD_U_0086::DoTestStepL()

  5167 	{

  5168 	TBool testOK = EFalse;

  5169 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCMU16, KMMFFourCCCodePCM16));

  5171 	if (err)

  5172 		{

  5173 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5174 		return EFail;

  5175 		}

  5176 	else if (!testOK)

  5177 		{

  5178 		INFO_PRINTF1(_L("Test failed"));

  5179 		return EFail;

  5180 		}

  5181 	else

  5182 		return EPass;

  5183 	}

  5185 //------------------------------------------------------------------

  5187 /** @xxxx

  5188  * Constructor

  5189  */

  5190 CTest_MMF_ACOD_U_0087::CTest_MMF_ACOD_U_0087()

  5191 	{

  5192 	// store the name of this test case

  5193 	// this is the name that is used by the script file

  5194 	// Each test step initialises it's own name

  5195 	iTestStepName = _L("MM-MMF-ACOD-U-0087-HP");

  5196 	}

  5198 /** @xxxx

  5199  * PCMU16 To PCM16 Instantiate codec by UID

  5200  * @test Req. under test REQ172.6.1, REQ172.11.25

  5201  */

  5202 TVerdict CTest_MMF_ACOD_U_0087::DoTestStepL()

  5203 	{

  5204 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

  5205 	TBool testOK = EFalse;

  5206 	TRAPD(err, testOK = TestNewL(codecUid));

  5208 	if (err)

  5209 		{

  5210 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5211 		return EFail;

  5212 		}

  5213 	else if (!testOK)

  5214 		{

  5215 		INFO_PRINTF1(_L("Test failed"));

  5216 		return EFail;

  5217 		}

  5218 	else

  5219 		return EPass;

  5220 	}

  5222 //------------------------------------------------------------------

  5224 /** @xxxx

  5225  * Constructor

  5226  */

  5227 CTest_MMF_ACOD_U_0088::CTest_MMF_ACOD_U_0088()

  5228 	{

  5229 	// store the name of this test case

  5230 	// this is the name that is used by the script file

  5231 	// Each test step initialises it's own name

  5232 	iTestStepName = _L("MM-MMF-ACOD-U-0088-HP");

  5234 	for (TUint i=0; i<5; i++)

  5235 		{

  5236 		iExpectedSrcBytesProcessed[i] = 50;

  5237 		iExpectedDstBytesAdded[i] = 50;

  5238 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  5239 		}

  5240 	}

  5242 /** @xxxx

  5243  * PCMU16 To PCM16 Pass in small source buffers

  5244  * @test Req. under test REQ172.6.4, REQ172.6.5

  5245  */

  5246 TVerdict CTest_MMF_ACOD_U_0088::DoTestStepL()

  5247 	{

  5248 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

  5249 	TBool testOK = EFalse;

  5250 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCMU16ToPCM16OptimumDst));

  5252 	if (err)

  5253 		{

  5254 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5255 		return EFail;

  5256 		}

  5257 	else if (!testOK)

  5258 		{

  5259 		INFO_PRINTF1(_L("Test failed"));

  5260 		return EFail;

  5261 		}

  5262 	else

  5263 		return EPass;

  5264 	}

  5266 //------------------------------------------------------------------

  5268 /** @xxxx

  5269  * Constructor

  5270  */

  5271 CTest_MMF_ACOD_U_0089::CTest_MMF_ACOD_U_0089()

  5272 	{

  5273 	// store the name of this test case

  5274 	// this is the name that is used by the script file

  5275 	// Each test step initialises it's own name

  5276 	iTestStepName = _L("MM-MMF-ACOD-U-0089-HP");

  5278 	for (TUint i=0; i<5; i++)

  5279 		{

  5280 		iExpectedSrcBytesProcessed[i] = 50;

  5281 		iExpectedDstBytesAdded[i] = 50;

  5282 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  5283 		}

  5284 	}

  5286 /** @xxxx

  5287  * PCMU16 To PCM16 Pass in small dest buffers

  5288  * @test Req. under test REQ172.6.4, REQ172.6.5

  5289  */

  5290 TVerdict CTest_MMF_ACOD_U_0089::DoTestStepL()

  5291 	{

  5292 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

  5293 	TBool testOK = EFalse;

  5294 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCMU16ToPCM16OptimumSrc, KSmallBufferSize));

  5296 	if (err)

  5297 		{

  5298 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5299 		return EFail;

  5300 		}

  5301 	else if (!testOK)

  5302 		{

  5303 		INFO_PRINTF1(_L("Test failed"));

  5304 		return EFail;

  5305 		}

  5306 	else

  5307 		return EPass;

  5308 	}

  5310 //------------------------------------------------------------------

  5312 /** @xxxx

  5313  * Constructor

  5314  */

  5315 CTest_MMF_ACOD_U_0090::CTest_MMF_ACOD_U_0090()

  5316 	{

  5317 	// store the name of this test case

  5318 	// this is the name that is used by the script file

  5319 	// Each test step initialises it's own name

  5320 	iTestStepName = _L("MM-MMF-ACOD-U-0090-HP");

  5321 	iHeapSize = 0x20000;

  5322 	for (TUint i=0; i<5; i++)

  5323 		{

  5324 		iExpectedSrcBytesProcessed[i] = 10000;

  5325 		iExpectedDstBytesAdded[i] = 10000;

  5326 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5327 		}

  5328 	}

  5330 /** @xxxx

  5331  * PCMU16 To PCM16 Pass in large buffers

  5332  * @test Req. under test REQ172.6.4, REQ172.6.5

  5333  */

  5334 TVerdict CTest_MMF_ACOD_U_0090::DoTestStepL()

  5335 	{

  5336 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

  5337 	TBool testOK = EFalse;

  5338 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  5340 	if (err)

  5341 		{

  5342 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5343 		return EFail;

  5344 		}

  5345 	else if (!testOK)

  5346 		{

  5347 		INFO_PRINTF1(_L("Test failed"));

  5348 		return EFail;

  5349 		}

  5350 	else

  5351 		return EPass;

  5352 	}

  5354 //------------------------------------------------------------------

  5356 /** @xxxx

  5357  * Constructor

  5358  */

  5359 CTest_MMF_ACOD_U_0091::CTest_MMF_ACOD_U_0091()

  5360 	{

  5361 	// store the name of this test case

  5362 	// this is the name that is used by the script file

  5363 	// Each test step initialises it's own name

  5364 	iTestStepName = _L("MM-MMF-ACOD-U-0091-HP");

  5366 	for (TUint i=0; i<5; i++)

  5367 		{

  5368 		iExpectedSrcBytesProcessed[i] = 0x1000;

  5369 		iExpectedDstBytesAdded[i] = 0x1000;

  5370 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5371 		}

  5372 	}

  5374 /** @xxxx

  5375  * PCMU16 To PCM16 Pass in default sized buffers

  5376  * @test Req. under test REQ172.6.4, REQ172.6.5

  5377  */

  5378 TVerdict CTest_MMF_ACOD_U_0091::DoTestStepL()

  5379 	{

  5380 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

  5381 	TBool testOK = EFalse;

  5382 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  5384 	if (err)

  5385 		{

  5386 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5387 		return EFail;

  5388 		}

  5389 	else if (!testOK)

  5390 		{

  5391 		INFO_PRINTF1(_L("Test failed"));

  5392 		return EFail;

  5393 		}

  5394 	else

  5395 		return EPass;

  5396 	}

  5398 //------------------------------------------------------------------

  5400 /** @xxxx

  5401  * Constructor

  5402  */

  5403 CTest_MMF_ACOD_U_0092::CTest_MMF_ACOD_U_0092()

  5404 	{

  5405 	// store the name of this test case

  5406 	// this is the name that is used by the script file

  5407 	// Each test step initialises it's own name

  5408 	iTestStepName = _L("MM-MMF-ACOD-U-0092-HP");

  5410 	for (TUint i=0; i<5; i++)

  5411 		{

  5412 		iExpectedSrcBytesProcessed[i] = 0x1000;

  5413 		iExpectedDstBytesAdded[i] = 0x1000;

  5414 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5415 		}

  5416 	}

  5418 /** @xxxx

  5419  * PCMU16 To PCM16 Pass in buffers with different max length and length

  5420  * @test Req. under test REQ172.6.4, REQ172.6.5

  5421  */

  5422 TVerdict CTest_MMF_ACOD_U_0092::DoTestStepL()

  5423 	{

  5424 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

  5425 	TBool testOK = EFalse;

  5426 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  5428 	if (err)

  5429 		{

  5430 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5431 		return EFail;

  5432 		}

  5433 	else if (!testOK)

  5434 		{

  5435 		INFO_PRINTF1(_L("Test failed"));

  5436 		return EFail;

  5437 		}

  5438 	else

  5439 		return EPass;

  5440 	}

  5442 //------------------------------------------------------------------

  5444 /** @xxxx

  5445  * Constructor

  5446  */

  5447 CTest_MMF_ACOD_U_0093::CTest_MMF_ACOD_U_0093()

  5448 	{

  5449 	// store the name of this test case

  5450 	// this is the name that is used by the script file

  5451 	// Each test step initialises it's own name

  5452 	iTestStepName = _L("MM-MMF-ACOD-U-0093-HP");

  5454 	for (TUint i=0; i<5; i++)

  5455 		{

  5456 		iExpectedSrcBytesProcessed[i] = 0x1000;

  5457 		iExpectedDstBytesAdded[i] = 0x1000;

  5458 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5459 		}

  5460 	}

  5462 /** @xxxx

  5463  * PCMU16 To PCM16 Pass in buffers of optimum size

  5464  * @test Req. under test REQ172.6.4, REQ172.6.5

  5465  */

  5466 TVerdict CTest_MMF_ACOD_U_0093::DoTestStepL()

  5467 	{

  5468 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

  5469 	TBool testOK = EFalse;

  5470 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCMU16ToPCM16OptimumSrc, KPCMU16ToPCM16OptimumDst));

  5472 	if (err)

  5473 		{

  5474 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5475 		return EFail;

  5476 		}

  5477 	else if (!testOK)

  5478 		{

  5479 		INFO_PRINTF1(_L("Test failed"));

  5480 		return EFail;

  5481 		}

  5482 	else

  5483 		return EPass;

  5484 	}

  5486 //------------------------------------------------------------------

  5488 /** @xxxx

  5489  * Constructor

  5490  */

  5491 CTest_MMF_ACOD_U_0094::CTest_MMF_ACOD_U_0094()

  5492 	{

  5493 	// store the name of this test case

  5494 	// this is the name that is used by the script file

  5495 	// Each test step initialises it's own name

  5496 	iTestStepName = _L("MM-MMF-ACOD-U-0094-HP");

  5497 	}

  5499 /** @xxxx

  5500  * PCMU16 To PCM16 Reposition source pointer during conversion

  5501  * @test Req. under test REQ172.11

  5502  */

  5503 TVerdict CTest_MMF_ACOD_U_0094::DoTestStepL()

  5504 	{

  5505 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

  5506 	TBool testOK = EFalse;

  5508 	INFO_PRINTF1(_L(">> The PCMU16 to PCM16 codec doesn't currently store data between calls to ProcessL"));

  5509 	TRAPD(err, testOK = TestRepositionL(codecUid, KDefaultBufferSize, KDefaultBufferSize+30));

  5511 	if (err)

  5512 		{

  5513 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5514 		return EFail;

  5515 		}

  5516 	else if (!testOK)

  5517 		{

  5518 		INFO_PRINTF1(_L("Test failed"));

  5519 		return EFail;

  5520 		}

  5521 	else

  5522 		return EPass;

  5523 	}

  5525 //------------------------------------------------------------------

  5527 /** @xxxx

  5528  * Constructor

  5529  */

  5530 CTest_MMF_ACOD_U_0095::CTest_MMF_ACOD_U_0095()

  5531 	{

  5532 	// store the name of this test case

  5533 	// this is the name that is used by the script file

  5534 	// Each test step initialises it's own name

  5535 	iTestStepName = _L("MM-MMF-ACOD-U-0095-HP");

  5536 	}

  5538 /** @xxxx

  5539  * PCMU8 To PCM16 Instantiate codec by FourCC Codes

  5540  * @test Req. under test REQ172.6.2, REQ172.11.11

  5541  */

  5542 TVerdict CTest_MMF_ACOD_U_0095::DoTestStepL()

  5543 	{

  5544 	TBool testOK = EFalse;

  5545 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCMU8, KMMFFourCCCodePCM16));

  5547 	if (err)

  5548 		{

  5549 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5550 		return EFail;

  5551 		}

  5552 	else if (!testOK)

  5553 		{

  5554 		INFO_PRINTF1(_L("Test failed"));

  5555 		return EFail;

  5556 		}

  5557 	else

  5558 		return EPass;

  5559 	}

  5561 //------------------------------------------------------------------

  5563 /** @xxxx

  5564  * Constructor

  5565  */

  5566 CTest_MMF_ACOD_U_0096::CTest_MMF_ACOD_U_0096()

  5567 	{

  5568 	// store the name of this test case

  5569 	// this is the name that is used by the script file

  5570 	// Each test step initialises it's own name

  5571 	iTestStepName = _L("MM-MMF-ACOD-U-0096-HP");

  5572 	}

  5574 /** @xxxx

  5575  * PCMU8 To PCM16 Instantiate codec by UID

  5576  * @test Req. under test REQ172.6.1, REQ172.11.11

  5577  */

  5578 TVerdict CTest_MMF_ACOD_U_0096::DoTestStepL()

  5579 	{

  5580 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

  5581 	TBool testOK = EFalse;

  5582 	TRAPD(err, testOK = TestNewL(codecUid));

  5584 	if (err)

  5585 		{

  5586 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5587 		return EFail;

  5588 		}

  5589 	else if (!testOK)

  5590 		{

  5591 		INFO_PRINTF1(_L("Test failed"));

  5592 		return EFail;

  5593 		}

  5594 	else

  5595 		return EPass;

  5596 	}

  5598 //------------------------------------------------------------------

  5600 /** @xxxx

  5601  * Constructor

  5602  */

  5603 CTest_MMF_ACOD_U_0097::CTest_MMF_ACOD_U_0097()

  5604 	{

  5605 	// store the name of this test case

  5606 	// this is the name that is used by the script file

  5607 	// Each test step initialises it's own name

  5608 	iTestStepName = _L("MM-MMF-ACOD-U-0097-HP");

  5610 	for (TUint i=0; i<5; i++)

  5611 		{

  5612 		iExpectedSrcBytesProcessed[i] = 50;

  5613 		iExpectedDstBytesAdded[i] = 100;

  5614 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  5615 		}

  5616 	}

  5618 /** @xxxx

  5619  * PCMU8 To PCM16 Pass in small source buffers

  5620  * @test Req. under test REQ172.6.4, REQ172.6.5

  5621  */

  5622 TVerdict CTest_MMF_ACOD_U_0097::DoTestStepL()

  5623 	{

  5624 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

  5625 	TBool testOK = EFalse;

  5626 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCMU8ToPCM16OptimumDst));

  5628 	if (err)

  5629 		{

  5630 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5631 		return EFail;

  5632 		}

  5633 	else if (!testOK)

  5634 		{

  5635 		INFO_PRINTF1(_L("Test failed"));

  5636 		return EFail;

  5637 		}

  5638 	else

  5639 		return EPass;

  5640 	}

  5642 //------------------------------------------------------------------

  5644 /** @xxxx

  5645  * Constructor

  5646  */

  5647 CTest_MMF_ACOD_U_0098::CTest_MMF_ACOD_U_0098()

  5648 	{

  5649 	// store the name of this test case

  5650 	// this is the name that is used by the script file

  5651 	// Each test step initialises it's own name

  5652 	iTestStepName = _L("MM-MMF-ACOD-U-0098-HP");

  5654 	for (TUint i=0; i<5; i++)

  5655 		{

  5656 		iExpectedSrcBytesProcessed[i] = 25;

  5657 		iExpectedDstBytesAdded[i] = 50;

  5658 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  5659 		}

  5660 	}

  5662 /** @xxxx

  5663  * PCMU8 To PCM16 Pass in small dest buffers

  5664  * @test Req. under test REQ172.6.4, REQ172.6.5

  5665  */

  5666 TVerdict CTest_MMF_ACOD_U_0098::DoTestStepL()

  5667 	{

  5668 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

  5669 	TBool testOK = EFalse;

  5670 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCMU8ToPCM16OptimumSrc, KSmallBufferSize));

  5672 	if (err)

  5673 		{

  5674 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5675 		return EFail;

  5676 		}

  5677 	else if (!testOK)

  5678 		{

  5679 		INFO_PRINTF1(_L("Test failed"));

  5680 		return EFail;

  5681 		}

  5682 	else

  5683 		return EPass;

  5684 	}

  5686 //------------------------------------------------------------------

  5688 /** @xxxx

  5689  * Constructor

  5690  */

  5691 CTest_MMF_ACOD_U_0099::CTest_MMF_ACOD_U_0099()

  5692 	{

  5693 	// store the name of this test case

  5694 	// this is the name that is used by the script file

  5695 	// Each test step initialises it's own name

  5696 	iTestStepName = _L("MM-MMF-ACOD-U-0099-HP");

  5697 	iHeapSize = 0x20000;

  5698 	for (TUint i=0; i<5; i++)

  5699 		{

  5700 		iExpectedSrcBytesProcessed[i] = 5000;

  5701 		iExpectedDstBytesAdded[i] = 10000;

  5703 		if((i%2)==0)//even i

  5704 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  5705 		else		//odd i

  5706 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5707 		}

  5708 	}

  5710 /** @xxxx

  5711  * PCMU8 To PCM16 Pass in large buffers

  5712  * @test Req. under test REQ172.6.4, REQ172.6.5

  5713  */

  5714 TVerdict CTest_MMF_ACOD_U_0099::DoTestStepL()

  5715 	{

  5716 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

  5717 	TBool testOK = EFalse;

  5718 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  5720 	if (err)

  5721 		{

  5722 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5723 		return EFail;

  5724 		}

  5725 	else if (!testOK)

  5726 		{

  5727 		INFO_PRINTF1(_L("Test failed"));

  5728 		return EFail;

  5729 		}

  5730 	else

  5731 		return EPass;

  5732 	}

  5734 //------------------------------------------------------------------

  5736 /** @xxxx

  5737  * Constructor

  5738  */

  5739 CTest_MMF_ACOD_U_0100::CTest_MMF_ACOD_U_0100()

  5740 	{

  5741 	// store the name of this test case

  5742 	// this is the name that is used by the script file

  5743 	// Each test step initialises it's own name

  5744 	iTestStepName = _L("MM-MMF-ACOD-U-0100-HP");

  5746 	for (TUint i=0; i<5; i++)

  5747 		{

  5748 		iExpectedSrcBytesProcessed[i] = 0x800;

  5749 		iExpectedDstBytesAdded[i] = 0x1000;

  5751 		if((i%2)==0)//even i

  5752 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  5753 		else		//odd i

  5754 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5755 		}

  5756 	}

  5758 /** @xxxx

  5759  * PCMU8 To PCM16 Pass in default sized buffers

  5760  * @test Req. under test REQ172.6.4, REQ172.6.5

  5761  */

  5762 TVerdict CTest_MMF_ACOD_U_0100::DoTestStepL()

  5763 	{

  5764 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

  5765 	TBool testOK = EFalse;

  5766 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  5768 	if (err)

  5769 		{

  5770 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5771 		return EFail;

  5772 		}

  5773 	else if (!testOK)

  5774 		{

  5775 		INFO_PRINTF1(_L("Test failed"));

  5776 		return EFail;

  5777 		}

  5778 	else

  5779 		return EPass;

  5780 	}

  5782 //------------------------------------------------------------------

  5784 /** @xxxx

  5785  * Constructor

  5786  */

  5787 CTest_MMF_ACOD_U_0101::CTest_MMF_ACOD_U_0101()

  5788 	{

  5789 	// store the name of this test case

  5790 	// this is the name that is used by the script file

  5791 	// Each test step initialises it's own name

  5792 	iTestStepName = _L("MM-MMF-ACOD-U-0101-HP");

  5794 	for (TUint i=0; i<5; i++)

  5795 		{

  5796 		iExpectedSrcBytesProcessed[i] = 0x800;

  5797 		iExpectedDstBytesAdded[i] = 0x1000;

  5799 		if((i%2)==0)//even i

  5800 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  5801 		else		//odd i

  5802 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5803 		}

  5804 	}

  5806 /** @xxxx

  5807  * PCMU8 To PCM16 Pass in buffers with different max length and length

  5808  * @test Req. under test REQ172.6.4, REQ172.6.5

  5809  */

  5810 TVerdict CTest_MMF_ACOD_U_0101::DoTestStepL()

  5811 	{

  5812 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

  5813 	TBool testOK = EFalse;

  5814 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  5816 	if (err)

  5817 		{

  5818 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5819 		return EFail;

  5820 		}

  5821 	else if (!testOK)

  5822 		{

  5823 		INFO_PRINTF1(_L("Test failed"));

  5824 		return EFail;

  5825 		}

  5826 	else

  5827 		return EPass;

  5828 	}

  5830 //------------------------------------------------------------------

  5832 /** @xxxx

  5833  * Constructor

  5834  */

  5835 CTest_MMF_ACOD_U_0102::CTest_MMF_ACOD_U_0102()

  5836 	{

  5837 	// store the name of this test case

  5838 	// this is the name that is used by the script file

  5839 	// Each test step initialises it's own name

  5840 	iTestStepName = _L("MM-MMF-ACOD-U-0102-HP");

  5842 	for (TUint i=0; i<5; i++)

  5843 		{

  5844 		iExpectedSrcBytesProcessed[i] = 0x800;

  5845 		iExpectedDstBytesAdded[i] = 0x1000;

  5846 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  5847 		}

  5848 	}

  5850 /** @xxxx

  5851  * PCMU8 To PCM16 Pass in buffers of optimum size

  5852  * @test Req. under test REQ172.6.4, REQ172.6.5

  5853  */

  5854 TVerdict CTest_MMF_ACOD_U_0102::DoTestStepL()

  5855 	{

  5856 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

  5857 	TBool testOK = EFalse;

  5858 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCMU8ToPCM16OptimumSrc, KPCMU8ToPCM16OptimumDst));

  5860 	if (err)

  5861 		{

  5862 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5863 		return EFail;

  5864 		}

  5865 	else if (!testOK)

  5866 		{

  5867 		INFO_PRINTF1(_L("Test failed"));

  5868 		return EFail;

  5869 		}

  5870 	else

  5871 		return EPass;

  5872 	}

  5874 //------------------------------------------------------------------

  5876 /** @xxxx

  5877  * Constructor

  5878  */

  5879 CTest_MMF_ACOD_U_0103::CTest_MMF_ACOD_U_0103()

  5880 	{

  5881 	// store the name of this test case

  5882 	// this is the name that is used by the script file

  5883 	// Each test step initialises it's own name

  5884 	iTestStepName = _L("MM-MMF-ACOD-U-0103-HP");

  5885 	}

  5887 /** @xxxx

  5888  * PCMU8 To PCM16 Reposition source pointer during conversion

  5889  * @test Req. under test REQ172.11

  5890  */

  5891 TVerdict CTest_MMF_ACOD_U_0103::DoTestStepL()

  5892 	{

  5893 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

  5894 	TBool testOK = EFalse;

  5895 	INFO_PRINTF1(_L(">> The PCMU8 to PCM16 codec doesn't currently store data between calls to ProcessL"));

  5897 	TRAPD(err, testOK = TestRepositionL(codecUid, KPCMU8ToPCM16OptimumSrc, KPCMU8ToPCM16OptimumDst+30));

  5899 	if (err)

  5900 		{

  5901 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5902 		return EFail;

  5903 		}

  5904 	else if (!testOK)

  5905 		{

  5906 		INFO_PRINTF1(_L("Test failed"));

  5907 		return EFail;

  5908 		}

  5909 	else

  5910 		return EPass;

  5911 	}

  5913 //------------------------------------------------------------------

  5916 /** @xxxx

  5917  * Constructor

  5918  */

  5919 CTest_MMF_ACOD_U_0104::CTest_MMF_ACOD_U_0104()

  5920 	{

  5921 	// store the name of this test case

  5922 	// this is the name that is used by the script file

  5923 	// Each test step initialises it's own name

  5924 	iTestStepName = _L("MM-MMF-ACOD-U-0104-HP");

  5925 	}

  5927 /** @xxxx

  5928  * MULAW To PCM16 Instantiate codec by FourCC Codes

  5929  * @test Req. under test REQ172.6.2, REQ172.11.13

  5930  */

  5931 TVerdict CTest_MMF_ACOD_U_0104::DoTestStepL()

  5932 	{

  5933 	TBool testOK = EFalse;

  5934 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodeMuLAW, KMMFFourCCCodePCM16));

  5936 	if (err)

  5937 		{

  5938 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5939 		return EFail;

  5940 		}

  5941 	else if (!testOK)

  5942 		{

  5943 		INFO_PRINTF1(_L("Test failed"));

  5944 		return EFail;

  5945 		}

  5946 	else

  5947 		return EPass;

  5948 	}

  5950 //------------------------------------------------------------------

  5952 /** @xxxx

  5953  * Constructor

  5954  */

  5955 CTest_MMF_ACOD_U_0105::CTest_MMF_ACOD_U_0105()

  5956 	{

  5957 	// store the name of this test case

  5958 	// this is the name that is used by the script file

  5959 	// Each test step initialises it's own name

  5960 	iTestStepName = _L("MM-MMF-ACOD-U-0105-HP");

  5961 	}

  5963 /** @xxxx

  5964  * MULAW To PCM16 Instantiate codec by UID

  5965  * @test Req. under test REQ172.6.1, REQ172.11.13

  5966  */

  5967 TVerdict CTest_MMF_ACOD_U_0105::DoTestStepL()

  5968 	{

  5969 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

  5970 	TBool testOK = EFalse;

  5971 	TRAPD(err, testOK = TestNewL(codecUid));

  5973 	if (err)

  5974 		{

  5975 		INFO_PRINTF2(_L("Test left with status %d"), err);

  5976 		return EFail;

  5977 		}

  5978 	else if (!testOK)

  5979 		{

  5980 		INFO_PRINTF1(_L("Test failed"));

  5981 		return EFail;

  5982 		}

  5983 	else

  5984 		return EPass;

  5985 	}

  5987 //------------------------------------------------------------------

  5989 /** @xxxx

  5990  * Constructor

  5991  */

  5992 CTest_MMF_ACOD_U_0106::CTest_MMF_ACOD_U_0106()

  5993 	{

  5994 	// store the name of this test case

  5995 	// this is the name that is used by the script file

  5996 	// Each test step initialises it's own name

  5997 	iTestStepName = _L("MM-MMF-ACOD-U-0106-HP");

  5999 	for (TUint i=0; i<5; i++)

  6000 		{

  6001 		iExpectedSrcBytesProcessed[i] = 50;

  6002 		iExpectedDstBytesAdded[i] = 100;

  6003 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  6004 		}

  6005 	}

  6007 /** @xxxx

  6008  * MULAW To PCM16 Pass in small source buffers

  6009  * @test Req. under test REQ172.6.4, REQ172.6.5

  6010  */

  6011 TVerdict CTest_MMF_ACOD_U_0106::DoTestStepL()

  6012 	{

  6013 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

  6014 	TBool testOK = EFalse;

  6015 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KMulawToPCM16OptimumDst));

  6017 	if (err)

  6018 		{

  6019 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6020 		return EFail;

  6021 		}

  6022 	else if (!testOK)

  6023 		{

  6024 		INFO_PRINTF1(_L("Test failed"));

  6025 		return EFail;

  6026 		}

  6027 	else

  6028 		return EPass;

  6029 	}

  6031 //------------------------------------------------------------------

  6033 /** @xxxx

  6034  * Constructor

  6035  */

  6036 CTest_MMF_ACOD_U_0107::CTest_MMF_ACOD_U_0107()

  6037 	{

  6038 	// store the name of this test case

  6039 	// this is the name that is used by the script file

  6040 	// Each test step initialises it's own name

  6041 	iTestStepName = _L("MM-MMF-ACOD-U-0107-HP");

  6043 	for (TUint i=0; i<5; i++)

  6044 		{

  6045 		iExpectedSrcBytesProcessed[i] = 25;

  6046 		iExpectedDstBytesAdded[i] = 50;

  6047 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  6048 		}

  6049 	}

  6051 /** @xxxx

  6052  * MULAW To PCM16 Pass in small dest buffers

  6053  * @test Req. under test REQ172.6.4, REQ172.6.5

  6054  */

  6055 TVerdict CTest_MMF_ACOD_U_0107::DoTestStepL()

  6056 	{

  6057 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

  6058 	TBool testOK = EFalse;

  6059 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMulawToPCM16OptimumSrc, KSmallBufferSize));

  6061 	if (err)

  6062 		{

  6063 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6064 		return EFail;

  6065 		}

  6066 	else if (!testOK)

  6067 		{

  6068 		INFO_PRINTF1(_L("Test failed"));

  6069 		return EFail;

  6070 		}

  6071 	else

  6072 		return EPass;

  6073 	}

  6075 //------------------------------------------------------------------

  6077 /** @xxxx

  6078  * Constructor

  6079  */

  6080 CTest_MMF_ACOD_U_0108::CTest_MMF_ACOD_U_0108()

  6081 	{

  6082 	// store the name of this test case

  6083 	// this is the name that is used by the script file

  6084 	// Each test step initialises it's own name

  6085 	iTestStepName = _L("MM-MMF-ACOD-U-0108-HP");

  6086 	iHeapSize = 0x20000;

  6087 	for (TUint i=0; i<5; i++)

  6088 		{

  6089 		iExpectedSrcBytesProcessed[i] = 5000;

  6090 		iExpectedDstBytesAdded[i] = 10000;

  6092 		if((i%2)==0)//even i

  6093 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  6094 		else		//odd i

  6095 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  6096 		}

  6097 	}

  6099 /** @xxxx

  6100  * MULAW To PCM16 Pass in large buffers

  6101  * @test Req. under test REQ172.6.4, REQ172.6.5

  6102  */

  6103 TVerdict CTest_MMF_ACOD_U_0108::DoTestStepL()

  6104 	{

  6105 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

  6106 	TBool testOK = EFalse;

  6107 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  6109 	if (err)

  6110 		{

  6111 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6112 		return EFail;

  6113 		}

  6114 	else if (!testOK)

  6115 		{

  6116 		INFO_PRINTF1(_L("Test failed"));

  6117 		return EFail;

  6118 		}

  6119 	else

  6120 		return EPass;

  6121 	}

  6123 //------------------------------------------------------------------

  6125 /** @xxxx

  6126  * Constructor

  6127  */

  6128 CTest_MMF_ACOD_U_0109::CTest_MMF_ACOD_U_0109()

  6129 	{

  6130 	// store the name of this test case

  6131 	// this is the name that is used by the script file

  6132 	// Each test step initialises it's own name

  6133 	iTestStepName = _L("MM-MMF-ACOD-U-0109-HP");

  6135 	for (TUint i=0; i<5; i++)

  6136 		{

  6137 		iExpectedSrcBytesProcessed[i] = 0x800;

  6138 		iExpectedDstBytesAdded[i] = 0x1000;

  6140 		if((i%2)==0)//even i

  6141 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  6142 		else		//odd i

  6143 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  6144 		}

  6145 	}

  6147 /** @xxxx

  6148  * MULAW To PCM16 Pass in default sized buffers

  6149  * @test Req. under test REQ172.6.4, REQ172.6.5

  6150  */

  6151 TVerdict CTest_MMF_ACOD_U_0109::DoTestStepL()

  6152 	{

  6153 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

  6154 	TBool testOK = EFalse;

  6155 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  6157 	if (err)

  6158 		{

  6159 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6160 		return EFail;

  6161 		}

  6162 	else if (!testOK)

  6163 		{

  6164 		INFO_PRINTF1(_L("Test failed"));

  6165 		return EFail;

  6166 		}

  6167 	else

  6168 		return EPass;

  6169 	}

  6171 //------------------------------------------------------------------

  6173 /** @xxxx

  6174  * Constructor

  6175  */

  6176 CTest_MMF_ACOD_U_0110::CTest_MMF_ACOD_U_0110()

  6177 	{

  6178 	// store the name of this test case

  6179 	// this is the name that is used by the script file

  6180 	// Each test step initialises it's own name

  6181 	iTestStepName = _L("MM-MMF-ACOD-U-0110-HP");

  6183 	for (TUint i=0; i<5; i++)

  6184 		{

  6185 		iExpectedSrcBytesProcessed[i] = 0x800;

  6186 		iExpectedDstBytesAdded[i] = 0x1000;

  6188 		if((i%2)==0)//even i

  6189 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  6190 		else		//odd i

  6191 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  6192 		}

  6193 	}

  6195 /** @xxxx

  6196  * MULAW To PCM16 Pass in buffers with different max length and length

  6197  * @test Req. under test REQ172.6.4, REQ172.6.5

  6198  */

  6199 TVerdict CTest_MMF_ACOD_U_0110::DoTestStepL()

  6200 	{

  6201 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

  6202 	TBool testOK = EFalse;

  6203 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  6205 	if (err)

  6206 		{

  6207 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6208 		return EFail;

  6209 		}

  6210 	else if (!testOK)

  6211 		{

  6212 		INFO_PRINTF1(_L("Test failed"));

  6213 		return EFail;

  6214 		}

  6215 	else

  6216 		return EPass;

  6217 	}

  6219 //------------------------------------------------------------------

  6221 /** @xxxx

  6222  * Constructor

  6223  */

  6224 CTest_MMF_ACOD_U_0111::CTest_MMF_ACOD_U_0111()

  6225 	{

  6226 	// store the name of this test case

  6227 	// this is the name that is used by the script file

  6228 	// Each test step initialises it's own name

  6229 	iTestStepName = _L("MM-MMF-ACOD-U-0111-HP");

  6231 	for (TUint i=0; i<5; i++)

  6232 		{

  6233 		iExpectedSrcBytesProcessed[i] = 0x800;

  6234 		iExpectedDstBytesAdded[i] = 0x1000;

  6235 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  6236 		}

  6237 	}

  6239 /** @xxxx

  6240  * MULAW To PCM16 Pass in buffers of optimum size

  6241  * @test Req. under test REQ172.6.4, REQ172.6.5

  6242  */

  6243 TVerdict CTest_MMF_ACOD_U_0111::DoTestStepL()

  6244 	{

  6245 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

  6246 	TBool testOK = EFalse;

  6247 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMulawToPCM16OptimumSrc, KMulawToPCM16OptimumDst));

  6249 	if (err)

  6250 		{

  6251 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6252 		return EFail;

  6253 		}

  6254 	else if (!testOK)

  6255 		{

  6256 		INFO_PRINTF1(_L("Test failed"));

  6257 		return EFail;

  6258 		}

  6259 	else

  6260 		return EPass;

  6261 	}

  6263 //------------------------------------------------------------------

  6265 /** @xxxx

  6266  * Constructor

  6267  */

  6268 CTest_MMF_ACOD_U_0112::CTest_MMF_ACOD_U_0112()

  6269 	{

  6270 	// store the name of this test case

  6271 	// this is the name that is used by the script file

  6272 	// Each test step initialises it's own name

  6273 	iTestStepName = _L("MM-MMF-ACOD-U-0112-HP");

  6274 	}

  6276 /** @xxxx

  6277  * MULAW To PCM16 Reposition source pointer during conversion

  6278  * @test Req. under test REQ172.11

  6279  */

  6280 TVerdict CTest_MMF_ACOD_U_0112::DoTestStepL()

  6281 	{

  6282 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

  6283 	TBool testOK = EFalse;

  6284 	INFO_PRINTF1(_L(">> The MULAW To PCM16 codec doesn't currently store data between calls to ProcessL"));

  6286 	TRAPD(err, testOK = TestRepositionL(codecUid, KMulawToPCM16OptimumSrc, KMulawToPCM16OptimumDst+30));

  6288 	if (err)

  6289 		{

  6290 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6291 		return EFail;

  6292 		}

  6293 	else if (!testOK)

  6294 		{

  6295 		INFO_PRINTF1(_L("Test failed"));

  6296 		return EFail;

  6297 		}

  6298 	else

  6299 		return EPass;

  6300 	}

  6302 //------------------------------------------------------------------

  6304 /** @xxxx

  6305  * Constructor

  6306  */

  6307 CTest_MMF_ACOD_U_0113::CTest_MMF_ACOD_U_0113()

  6308 	{

  6309 	// store the name of this test case

  6310 	// this is the name that is used by the script file

  6311 	// Each test step initialises it's own name

  6312 	iTestStepName = _L("MM-MMF-ACOD-U-0113-HP");

  6313 	}

  6315 /** @xxxx

  6316  * PCM16 To MULAW Instantiate codec by FourCC Codes

  6317  * @test Req. under test REQ172.6.2, REQ172.11.15

  6318  */

  6319 TVerdict CTest_MMF_ACOD_U_0113::DoTestStepL()

  6320 	{

  6321 	TBool testOK = EFalse;

  6322 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodeMuLAW));

  6324 	if (err)

  6325 		{

  6326 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6327 		return EFail;

  6328 		}

  6329 	else if (!testOK)

  6330 		{

  6331 		INFO_PRINTF1(_L("Test failed"));

  6332 		return EFail;

  6333 		}

  6334 	else

  6335 		return EPass;

  6336 	}

  6338 //------------------------------------------------------------------

  6340 /** @xxxx

  6341  * Constructor

  6342  */

  6343 CTest_MMF_ACOD_U_0114::CTest_MMF_ACOD_U_0114()

  6344 	{

  6345 	// store the name of this test case

  6346 	// this is the name that is used by the script file

  6347 	// Each test step initialises it's own name

  6348 	iTestStepName = _L("MM-MMF-ACOD-U-0114-HP");

  6349 	}

  6351 /** @xxxx

  6352  * PCM16 To MULAW Instantiate codec by UID

  6353  * @test Req. under test REQ172.6.1, REQ172.11.15

  6354  */

  6355 TVerdict CTest_MMF_ACOD_U_0114::DoTestStepL()

  6356 	{

  6357 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

  6358 	TBool testOK = EFalse;

  6359 	TRAPD(err, testOK = TestNewL(codecUid));

  6361 	if (err)

  6362 		{

  6363 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6364 		return EFail;

  6365 		}

  6366 	else if (!testOK)

  6367 		{

  6368 		INFO_PRINTF1(_L("Test failed"));

  6369 		return EFail;

  6370 		}

  6371 	else

  6372 		return EPass;

  6373 	}

  6375 //------------------------------------------------------------------

  6377 /** @xxxx

  6378  * Constructor

  6379  */

  6380 CTest_MMF_ACOD_U_0115::CTest_MMF_ACOD_U_0115()

  6381 	{

  6382 	// store the name of this test case

  6383 	// this is the name that is used by the script file

  6384 	// Each test step initialises it's own name

  6385 	iTestStepName = _L("MM-MMF-ACOD-U-0115-HP");

  6387 	for (TUint i=0; i<5; i++)

  6388 		{

  6389 		iExpectedSrcBytesProcessed[i] = 50;

  6390 		iExpectedDstBytesAdded[i] = 25;

  6391 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  6392 		}

  6393 	}

  6395 /** @xxxx

  6396  * PCM16 To MULAW Pass in small source buffers

  6397  * @test Req. under test REQ172.6.4, REQ172.6.5

  6398  */

  6399 TVerdict CTest_MMF_ACOD_U_0115::DoTestStepL()

  6400 	{

  6401 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

  6402 	TBool testOK = EFalse;

  6403 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM16ToMulawOptimumDst));

  6405 	if (err)

  6406 		{

  6407 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6408 		return EFail;

  6409 		}

  6410 	else if (!testOK)

  6411 		{

  6412 		INFO_PRINTF1(_L("Test failed"));

  6413 		return EFail;

  6414 		}

  6415 	else

  6416 		return EPass;

  6417 	}

  6419 //------------------------------------------------------------------

  6421 /** @xxxx

  6422  * Constructor

  6423  */

  6424 CTest_MMF_ACOD_U_0116::CTest_MMF_ACOD_U_0116()

  6425 	{

  6426 	// store the name of this test case

  6427 	// this is the name that is used by the script file

  6428 	// Each test step initialises it's own name

  6429 	iTestStepName = _L("MM-MMF-ACOD-U-0116-HP");

  6431 	for (TUint i=0; i<5; i++)

  6432 		{

  6433 		iExpectedSrcBytesProcessed[i] = 100;

  6434 		iExpectedDstBytesAdded[i] = 50;

  6435 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  6436 		}

  6437 	}

  6439 /** @xxxx

  6440  * PCM16 To MULAW Pass in small dest buffers

  6441  * @test Req. under test REQ172.6.4, REQ172.6.5

  6442  */

  6443 TVerdict CTest_MMF_ACOD_U_0116::DoTestStepL()

  6444 	{

  6445 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

  6446 	TBool testOK = EFalse;

  6447 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToMulawOptimumSrc, KSmallBufferSize));

  6449 	if (err)

  6450 		{

  6451 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6452 		return EFail;

  6453 		}

  6454 	else if (!testOK)

  6455 		{

  6456 		INFO_PRINTF1(_L("Test failed"));

  6457 		return EFail;

  6458 		}

  6459 	else

  6460 		return EPass;

  6461 	}

  6463 //------------------------------------------------------------------

  6465 /** @xxxx

  6466  * Constructor

  6467  */

  6468 CTest_MMF_ACOD_U_0117::CTest_MMF_ACOD_U_0117()

  6469 	{

  6470 	// store the name of this test case

  6471 	// this is the name that is used by the script file

  6472 	// Each test step initialises it's own name

  6473 	iTestStepName = _L("MM-MMF-ACOD-U-0117-HP");

  6474 	iHeapSize = 0x20000;

  6476 	for (TUint i=0; i<5; i++)

  6477 		{

  6478 		iExpectedSrcBytesProcessed[i] = 10000;

  6479 		iExpectedDstBytesAdded[i] = 5000;

  6481 		if((i%2)==0)//even i

  6482 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  6483 		else		//odd i

  6484 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  6485 		}

  6486 	}

  6488 /** @xxxx

  6489  * PCM16 To MULAW Pass in large buffers

  6490  * @test Req. under test REQ172.6.4, REQ172.6.5

  6491  */

  6492 TVerdict CTest_MMF_ACOD_U_0117::DoTestStepL()

  6493 	{

  6494 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

  6495 	TBool testOK = EFalse;

  6496 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize));

  6498 	if (err)

  6499 		{

  6500 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6501 		return EFail;

  6502 		}

  6503 	else if (!testOK)

  6504 		{

  6505 		INFO_PRINTF1(_L("Test failed"));

  6506 		return EFail;

  6507 		}

  6508 	else

  6509 		return EPass;

  6510 	}

  6512 //------------------------------------------------------------------

  6514 /** @xxxx

  6515  * Constructor

  6516  */

  6517 CTest_MMF_ACOD_U_0118::CTest_MMF_ACOD_U_0118()

  6518 	{

  6519 	// store the name of this test case

  6520 	// this is the name that is used by the script file

  6521 	// Each test step initialises it's own name

  6522 	iTestStepName = _L("MM-MMF-ACOD-U-0118-HP");

  6524 	for (TUint i=0; i<5; i++)

  6525 		{

  6526 		iExpectedSrcBytesProcessed[i] = 0x1000;

  6527 		iExpectedDstBytesAdded[i] = 0x800;

  6529 		if((i%2)==0)//even i

  6530 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  6531 		else		//odd i

  6532 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  6533 		}

  6534 	}

  6536 /** @xxxx

  6537  * PCM16 To MULAW Pass in default sized buffers

  6538  * @test Req. under test REQ172.6.4, REQ172.6.5

  6539  */

  6540 TVerdict CTest_MMF_ACOD_U_0118::DoTestStepL()

  6541 	{

  6542 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

  6543 	TBool testOK = EFalse;

  6544 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize));

  6546 	if (err)

  6547 		{

  6548 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6549 		return EFail;

  6550 		}

  6551 	else if (!testOK)

  6552 		{

  6553 		INFO_PRINTF1(_L("Test failed"));

  6554 		return EFail;

  6555 		}

  6556 	else

  6557 		return EPass;

  6558 	}

  6560 //------------------------------------------------------------------

  6562 /** @xxxx

  6563  * Constructor

  6564  */

  6565 CTest_MMF_ACOD_U_0119::CTest_MMF_ACOD_U_0119()

  6566 	{

  6567 	// store the name of this test case

  6568 	// this is the name that is used by the script file

  6569 	// Each test step initialises it's own name

  6570 	iTestStepName = _L("MM-MMF-ACOD-U-0119-HP");

  6572 	for (TUint i=0; i<5; i++)

  6573 		{

  6574 		iExpectedSrcBytesProcessed[i] = 0x1000;

  6575 		iExpectedDstBytesAdded[i] = 0x800;

  6577 		if((i%2)==0)//even i

  6578 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  6579 		else		//odd i

  6580 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  6581 		}

  6582 	}

  6584 /** @xxxx

  6585  * PCM16 To MULAW Pass in buffers with different max length and length

  6586  * @test Req. under test REQ172.6.4, REQ172.6.5

  6587  */

  6588 TVerdict CTest_MMF_ACOD_U_0119::DoTestStepL()

  6589 	{

  6590 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

  6591 	TBool testOK = EFalse;

  6592 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize));

  6594 	if (err)

  6595 		{

  6596 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6597 		return EFail;

  6598 		}

  6599 	else if (!testOK)

  6600 		{

  6601 		INFO_PRINTF1(_L("Test failed"));

  6602 		return EFail;

  6603 		}

  6604 	else

  6605 		return EPass;

  6606 	}

  6608 //------------------------------------------------------------------

  6610 /** @xxxx

  6611  * Constructor

  6612  */

  6613 CTest_MMF_ACOD_U_0120::CTest_MMF_ACOD_U_0120()

  6614 	{

  6615 	// store the name of this test case

  6616 	// this is the name that is used by the script file

  6617 	// Each test step initialises it's own name

  6618 	iTestStepName = _L("MM-MMF-ACOD-U-0120-HP");

  6620 	for (TUint i=0; i<5; i++)

  6621 		{

  6622 		iExpectedSrcBytesProcessed[i] = 0x1000;

  6623 		iExpectedDstBytesAdded[i] = 0x800;

  6624 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  6625 		}

  6626 	}

  6628 /** @xxxx

  6629  * PCM16 To MULAW Pass in buffers of optimum size

  6630  * @test Req. under test REQ172.6.4, REQ172.6.5

  6631  */

  6632 TVerdict CTest_MMF_ACOD_U_0120::DoTestStepL()

  6633 	{

  6634 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

  6635 	TBool testOK = EFalse;

  6636 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToMulawOptimumSrc, KPCM16ToMulawOptimumDst));

  6638 	if (err)

  6639 		{

  6640 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6641 		return EFail;

  6642 		}

  6643 	else if (!testOK)

  6644 		{

  6645 		INFO_PRINTF1(_L("Test failed"));

  6646 		return EFail;

  6647 		}

  6648 	else

  6649 		return EPass;

  6650 	}

  6652 //------------------------------------------------------------------

  6654 /** @xxxx

  6655  * Constructor

  6656  */

  6657 CTest_MMF_ACOD_U_0121::CTest_MMF_ACOD_U_0121()

  6658 	{

  6659 	// store the name of this test case

  6660 	// this is the name that is used by the script file

  6661 	// Each test step initialises it's own name

  6662 	iTestStepName = _L("MM-MMF-ACOD-U-0121-HP");

  6663 	}

  6665 /** @xxxx

  6666  * PCM16 To MULAW Reposition source pointer during conversion

  6667  * @test Req. under test REQ172.11

  6668  */

  6669 TVerdict CTest_MMF_ACOD_U_0121::DoTestStepL()

  6670 	{

  6671 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

  6672 	TBool testOK = EFalse;

  6674 	INFO_PRINTF1(_L(">> The PCM16 to MULAW codec doesn't currently store data between calls to ProcessL"));

  6675 	TRAPD(err, testOK = TestRepositionL(codecUid, KDefaultBufferSize, KDefaultBufferSize+30));

  6677 	if (err)

  6678 		{

  6679 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6680 		return EFail;

  6681 		}

  6682 	else if (!testOK)

  6683 		{

  6684 		INFO_PRINTF1(_L("Test failed"));

  6685 		return EFail;

  6686 		}

  6687 	else

  6688 		return EPass;

  6689 	}

  6691 //------------------------------------------------------------------

  6693 /** @xxxx

  6694  * Constructor

  6695  */

  6696 CTest_MMF_ACOD_U_0122::CTest_MMF_ACOD_U_0122()

  6697 	{

  6698 	// store the name of this test case

  6699 	// this is the name that is used by the script file

  6700 	// Each test step initialises it's own name

  6701 	iTestStepName = _L("MM-MMF-ACOD-U-0122-HP");

  6702 	}

  6704 /** @xxxx

  6705  * IMAD to PCM16 Instantiate codec by FourCC Codes

  6706  * @test Req. under test REQ172.6.2, REQ172.11.12

  6707  */

  6708 TVerdict CTest_MMF_ACOD_U_0122::DoTestStepL()

  6709 	{

  6710 	TBool testOK = EFalse;

  6711 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodeIMAD, KMMFFourCCCodePCM16));

  6713 	if (err)

  6714 		{

  6715 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6716 		return EFail;

  6717 		}

  6718 	else if (!testOK)

  6719 		{

  6720 		INFO_PRINTF1(_L("Test failed"));

  6721 		return EFail;

  6722 		}

  6723 	else

  6724 		return EPass;

  6725 	}

  6727 //------------------------------------------------------------------

  6729 /** @xxxx

  6730  * Constructor

  6731  */

  6732 CTest_MMF_ACOD_U_0123::CTest_MMF_ACOD_U_0123()

  6733 	{

  6734 	// store the name of this test case

  6735 	// this is the name that is used by the script file

  6736 	// Each test step initialises it's own name

  6737 	iTestStepName = _L("MM-MMF-ACOD-U-0123-HP");

  6738 	}

  6740 /** @xxxx

  6741  * IMAD to PCM16 Instantiate codec by UID

  6742  * @test Req. under test REQ172.6.1, REQ172.11.12

  6743  */

  6744 TVerdict CTest_MMF_ACOD_U_0123::DoTestStepL()

  6745 	{

  6746 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

  6747 	TBool testOK = EFalse;

  6748 	TRAPD(err, testOK = TestNewL(codecUid));

  6750 	if (err)

  6751 		{

  6752 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6753 		return EFail;

  6754 		}

  6755 	else if (!testOK)

  6756 		{

  6757 		INFO_PRINTF1(_L("Test failed"));

  6758 		return EFail;

  6759 		}

  6760 	else

  6761 		return EPass;

  6762 	}

  6764 //------------------------------------------------------------------

  6766 /** @xxxx

  6767  * Constructor

  6768  */

  6769 CTest_MMF_ACOD_U_0124::CTest_MMF_ACOD_U_0124()

  6770 	{

  6771 	// store the name of this test case

  6772 	// this is the name that is used by the script file

  6773 	// Each test step initialises it's own name

  6774 	iTestStepName = _L("MM-MMF-ACOD-U-0124-HP");

  6776 	for (TUint i=0; i<5; i++)

  6777 		{

  6778 		iExpectedSrcBytesProcessed[i] = 50;

  6779 		iExpectedDstBytesAdded[i] = 0;

  6780 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  6781 		}

  6782 	}

  6784 /** @xxxx

  6785  * IMAD to PCM16 Pass in small source buffers

  6786  * @test Req. under test REQ172.6.4, REQ172.6.5

  6787  */

  6788 TVerdict CTest_MMF_ACOD_U_0124::DoTestStepL()

  6789 	{

  6790 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

  6791 	TBool testOK = EFalse;

  6792 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KAdpcmToPCM16OptimumDst));

  6794 	if (err)

  6795 		{

  6796 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6797 		return EFail;

  6798 		}

  6799 	else if (!testOK)

  6800 		{

  6801 		INFO_PRINTF1(_L("Test failed"));

  6802 		return EFail;

  6803 		}

  6804 	else

  6805 		return EPass;

  6806 	}

  6808 //------------------------------------------------------------------

  6810 /** @xxxx

  6811  * Constructor

  6812  */

  6813 CTest_MMF_ACOD_U_0125::CTest_MMF_ACOD_U_0125()

  6814 	{

  6815 	// store the name of this test case

  6816 	// this is the name that is used by the script file

  6817 	// Each test step initialises it's own name

  6818 	iTestStepName = _L("MM-MMF-ACOD-U-0125-HP");

  6820 	iExpectedLeaveErrorCode = KErrArgument;

  6821 	}

  6823 /** @xxxx

  6824  * IMAD to PCM16 Pass in small dest buffers

  6825  * @test Req. under test REQ172.6.4, REQ172.6.5

  6826  */

  6827 TVerdict CTest_MMF_ACOD_U_0125::DoTestStepL()

  6828 	{

  6829 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

  6830 	TBool testOK = EFalse;

  6831 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KAdpcmToPCM16OptimumSrc, KSmallBufferSize));

  6833 	if (err)

  6834 		{

  6835 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6836 		return EFail;

  6837 		}

  6838 	else if (!testOK)

  6839 		{

  6840 		INFO_PRINTF1(_L("Test failed"));

  6841 		return EFail;

  6842 		}

  6843 	else

  6844 		return EPass;

  6845 	}

  6847 //------------------------------------------------------------------

  6849 /** @xxxx

  6850  * Constructor

  6851  */

  6852 CTest_MMF_ACOD_U_0126::CTest_MMF_ACOD_U_0126()

  6853 	{

  6854 	// store the name of this test case

  6855 	// this is the name that is used by the script file

  6856 	// Each test step initialises it's own name

  6857 	iTestStepName = _L("MM-MMF-ACOD-U-0126-HP");

  6858 	iHeapSize = 0x20000;

  6860 	for (TUint i=0; i<5; i++)

  6861 		{

  6862 		if(i<4)

  6863 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  6864 		else

  6865 			iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  6866 		}

  6867 	}

  6869 /** @xxxx

  6870  * IMAD to PCM16 Pass in large buffers

  6871  * @test Req. under test REQ172.6.4, REQ172.6.5

  6872  */

  6873 TVerdict CTest_MMF_ACOD_U_0126::DoTestStepL()

  6874 	{

  6875 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

  6876 	TBool testOK = EFalse;

  6877 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize, 0, EFalse));

  6879 	if (err)

  6880 		{

  6881 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6882 		return EFail;

  6883 		}

  6884 	else if (!testOK)

  6885 		{

  6886 		INFO_PRINTF1(_L("Test failed"));

  6887 		return EFail;

  6888 		}

  6889 	else

  6890 		return EPass;

  6891 	}

  6893 //------------------------------------------------------------------

  6895 /** @xxxx

  6896  * Constructor

  6897  */

  6898 CTest_MMF_ACOD_U_0127::CTest_MMF_ACOD_U_0127()

  6899 	{

  6900 	// store the name of this test case

  6901 	// this is the name that is used by the script file

  6902 	// Each test step initialises it's own name

  6903 	iTestStepName = _L("MM-MMF-ACOD-U-0127-HP");

  6905 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EProcessIncomplete;

  6906 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EProcessIncomplete;

  6907 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EProcessIncomplete;

  6908 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessComplete;

  6909 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EProcessIncomplete;

  6910 	}

  6912 /** @xxxx

  6913  * IMAD to PCM16 Pass in default sized buffers

  6914  * @test Req. under test REQ172.6.4, REQ172.6.5

  6915  */

  6916 TVerdict CTest_MMF_ACOD_U_0127::DoTestStepL()

  6917 	{

  6918 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

  6919 	TBool testOK = EFalse;

  6920 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize, 0, EFalse));

  6922 	if (err)

  6923 		{

  6924 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6925 		return EFail;

  6926 		}

  6927 	else if (!testOK)

  6928 		{

  6929 		INFO_PRINTF1(_L("Test failed"));

  6930 		return EFail;

  6931 		}

  6932 	else

  6933 		return EPass;

  6934 	}

  6936 //------------------------------------------------------------------

  6938 /** @xxxx

  6939  * Constructor

  6940  */

  6941 CTest_MMF_ACOD_U_0128::CTest_MMF_ACOD_U_0128()

  6942 	{

  6943 	// store the name of this test case

  6944 	// this is the name that is used by the script file

  6945 	// Each test step initialises it's own name

  6946 	iTestStepName = _L("MM-MMF-ACOD-U-0128-HP");

  6948 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EProcessIncomplete;

  6949 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EProcessIncomplete;

  6950 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EProcessIncomplete;

  6951 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessComplete;

  6952 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EProcessIncomplete;

  6953 	}

  6955 /** @xxxx

  6956  * IMAD to PCM16 Pass in buffers with different max length and length

  6957  * @test Req. under test REQ172.6.4, REQ172.6.5

  6958  */

  6959 TVerdict CTest_MMF_ACOD_U_0128::DoTestStepL()

  6960 	{

  6961 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

  6962 	TBool testOK = EFalse;

  6963 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize, EFalse));

  6965 	if (err)

  6966 		{

  6967 		INFO_PRINTF2(_L("Test left with status %d"), err);

  6968 		return EFail;

  6969 		}

  6970 	else if (!testOK)

  6971 		{

  6972 		INFO_PRINTF1(_L("Test failed"));

  6973 		return EFail;

  6974 		}

  6975 	else

  6976 		return EPass;

  6977 	}

  6979 //------------------------------------------------------------------

  6981 /** @xxxx

  6982  * Constructor

  6983  */

  6984 CTest_MMF_ACOD_U_0129::CTest_MMF_ACOD_U_0129()

  6985 	{

  6986 	// store the name of this test case

  6987 	// this is the name that is used by the script file

  6988 	// Each test step initialises it's own name

  6989 	iTestStepName = _L("MM-MMF-ACOD-U-0129-HP");

  6991 	for (TUint i=0; i<5; i++)

  6992 		{

  6993 		iExpectedSrcBytesProcessed[i] = 0x400;

  6994 		iExpectedDstBytesAdded[i] = 0xFC8;

  6995 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  6996 		}

  6997 	}

  6999 /** @xxxx

  7000  * IMAD to PCM16 Pass in buffers of optimum size

  7001  * @test Req. under test REQ172.6.4, REQ172.6.5

  7002  */

  7003 TVerdict CTest_MMF_ACOD_U_0129::DoTestStepL()

  7004 	{

  7005 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

  7006 	TBool testOK = EFalse;

  7007 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KAdpcmToPCM16OptimumSrc, KAdpcmToPCM16OptimumDst));

  7009 	if (err)

  7010 		{

  7011 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7012 		return EFail;

  7013 		}

  7014 	else if (!testOK)

  7015 		{

  7016 		INFO_PRINTF1(_L("Test failed"));

  7017 		return EFail;

  7018 		}

  7019 	else

  7020 		return EPass;

  7021 	}

  7023 //------------------------------------------------------------------

  7025 /** @xxxx

  7026  * Constructor

  7027  */

  7028 CTest_MMF_ACOD_U_0130::CTest_MMF_ACOD_U_0130()

  7029 	{

  7030 	// store the name of this test case

  7031 	// this is the name that is used by the script file

  7032 	// Each test step initialises it's own name

  7033 	iTestStepName = _L("MM-MMF-ACOD-U-0130-HP");

  7034 	}

  7036 /** @xxxx

  7037  * IMAD to PCM16 Reposition source pointer during conversion

  7038  * @test Req. under test REQ172.11

  7039  */

  7040 TVerdict CTest_MMF_ACOD_U_0130::DoTestStepL()

  7041 	{

  7042 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

  7043 	TBool testOK = EFalse;

  7045 	TUint src = (KAdpcmToPCM16OptimumSrc/4) + 10;

  7047 	INFO_PRINTF1(_L(">> The IMAD to PCM16 codec stores data between calls to ProcessL"));

  7048 	TRAPD(err, testOK = TestRepositionL(codecUid, src, KAdpcmToPCM16OptimumDst));

  7050 	if (err)

  7051 		{

  7052 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7053 		return EFail;

  7054 		}

  7055 	else if (!testOK)

  7056 		{

  7057 		INFO_PRINTF1(_L("Test failed"));

  7058 		return EFail;

  7059 		}

  7060 	else

  7061 		return EPass;

  7062 	}

  7064 //------------------------------------------------------------------

  7066 /** @xxxx

  7067  * Constructor

  7068  */

  7069 CTest_MMF_ACOD_U_0131::CTest_MMF_ACOD_U_0131()

  7070 	{

  7071 	// store the name of this test case

  7072 	// this is the name that is used by the script file

  7073 	// Each test step initialises it's own name

  7074 	iTestStepName = _L("MM-MMF-ACOD-U-0131-HP");

  7075 	}

  7077 /** @xxxx

  7078  *  PCM16 to IMAD Instantiate codec by FourCC Codes

  7079  * @test Req. under test REQ172.6.2, REQ172.11.14

  7080  */

  7081 TVerdict CTest_MMF_ACOD_U_0131::DoTestStepL()

  7082 	{

  7083 	TBool testOK = EFalse;

  7084 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodeIMAD));

  7086 	if (err)

  7087 		{

  7088 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7089 		return EFail;

  7090 		}

  7091 	else if (!testOK)

  7092 		{

  7093 		INFO_PRINTF1(_L("Test failed"));

  7094 		return EFail;

  7095 		}

  7096 	else

  7097 		return EPass;

  7098 	}

  7100 //------------------------------------------------------------------

  7102 /** @xxxx

  7103  * Constructor

  7104  */

  7105 CTest_MMF_ACOD_U_0132::CTest_MMF_ACOD_U_0132()

  7106 	{

  7107 	// store the name of this test case

  7108 	// this is the name that is used by the script file

  7109 	// Each test step initialises it's own name

  7110 	iTestStepName = _L("MM-MMF-ACOD-U-0132-HP");

  7111 	}

  7113 /** @xxxx

  7114  * PCM16 to IMAD Instantiate codec by UID

  7115  * @test Req. under test REQ172.6.1, REQ172.11.14

  7116  */

  7117 TVerdict CTest_MMF_ACOD_U_0132::DoTestStepL()

  7118 	{

  7119 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

  7120 	TBool testOK = EFalse;

  7121 	TRAPD(err, testOK = TestNewL(codecUid));

  7123 	if (err)

  7124 		{

  7125 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7126 		return EFail;

  7127 		}

  7128 	else if (!testOK)

  7129 		{

  7130 		INFO_PRINTF1(_L("Test failed"));

  7131 		return EFail;

  7132 		}

  7133 	else

  7134 		return EPass;

  7135 	}

  7137 //------------------------------------------------------------------

  7139 /** @xxxx

  7140  * Constructor

  7141  */

  7142 CTest_MMF_ACOD_U_0133::CTest_MMF_ACOD_U_0133()

  7143 	{

  7144 	// store the name of this test case

  7145 	// this is the name that is used by the script file

  7146 	// Each test step initialises it's own name

  7147 	iTestStepName = _L("MM-MMF-ACOD-U-0133-HP");

  7149 	for (TUint i=0; i<5; i++)

  7150 		{

  7151 		iExpectedSrcBytesProcessed[i] = 50;

  7152 		iExpectedDstBytesAdded[i] = 0;

  7153 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  7154 		}

  7155 	}

  7157 /** @xxxx

  7158  * IMAD to PCM16 Pass in small source buffers

  7159  * @test Req. under test REQ172.6.4, REQ172.6.5

  7160  */

  7161 TVerdict CTest_MMF_ACOD_U_0133::DoTestStepL()

  7162 	{

  7163 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

  7164 	TBool testOK = EFalse;

  7165 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM16ToAdpcmOptimumDst));

  7167 	if (err)

  7168 		{

  7169 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7170 		return EFail;

  7171 		}

  7172 	else if (!testOK)

  7173 		{

  7174 		INFO_PRINTF1(_L("Test failed"));

  7175 		return EFail;

  7176 		}

  7177 	else

  7178 		return EPass;

  7179 	}

  7181 //------------------------------------------------------------------

  7183 /** @xxxx

  7184  * Constructor

  7185  */

  7186 CTest_MMF_ACOD_U_0134::CTest_MMF_ACOD_U_0134()

  7187 	{

  7188 	// store the name of this test case

  7189 	// this is the name that is used by the script file

  7190 	// Each test step initialises it's own name

  7191 	iTestStepName = _L("MM-MMF-ACOD-U-0134-HP");

  7193 	iExpectedLeaveErrorCode = KErrArgument;

  7194 	}

  7196 /** @xxxx

  7197  * PCM16 to IMAD Pass in small dest buffers

  7198  * @test Req. under test REQ172.6.4, REQ172.6.5

  7199  */

  7200 TVerdict CTest_MMF_ACOD_U_0134::DoTestStepL()

  7201 	{

  7202 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

  7203 	TBool testOK = EFalse;

  7204 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToAdpcmOptimumSrc, KSmallBufferSize));

  7206 	if (err)

  7207 		{

  7208 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7209 		return EFail;

  7210 		}

  7211 	else if (!testOK)

  7212 		{

  7213 		INFO_PRINTF1(_L("Test failed"));

  7214 		return EFail;

  7215 		}

  7216 	else

  7217 		return EPass;

  7218 	}

  7220 //------------------------------------------------------------------

  7222 /** @xxxx

  7223  * Constructor

  7224  */

  7225 CTest_MMF_ACOD_U_0135::CTest_MMF_ACOD_U_0135()

  7226 	{

  7227 	// store the name of this test case

  7228 	// this is the name that is used by the script file

  7229 	// Each test step initialises it's own name

  7230 	iTestStepName = _L("MM-MMF-ACOD-U-0135-HP");

  7231 	iHeapSize = 0x20000;

  7232 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EDstNotFilled;

  7233 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EDstNotFilled;

  7234 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EDstNotFilled;

  7235 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessIncomplete;

  7236 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EDstNotFilled;

  7237 	}

  7239 /** @xxxx

  7240  * PCM16 to IMAD Pass in large buffers

  7241  * @test Req. under test REQ172.6.4, REQ172.6.5

  7242  */

  7243 TVerdict CTest_MMF_ACOD_U_0135::DoTestStepL()

  7244 	{

  7245 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

  7246 	TBool testOK = EFalse;

  7247 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize, 0, EFalse));

  7249 	if (err)

  7250 		{

  7251 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7252 		return EFail;

  7253 		}

  7254 	else if (!testOK)

  7255 		{

  7256 		INFO_PRINTF1(_L("Test failed"));

  7257 		return EFail;

  7258 		}

  7259 	else

  7260 		return EPass;

  7261 	}

  7263 //------------------------------------------------------------------

  7265 /** @xxxx

  7266  * Constructor

  7267  */

  7268 CTest_MMF_ACOD_U_0136::CTest_MMF_ACOD_U_0136()

  7269 	{

  7270 	// store the name of this test case

  7271 	// this is the name that is used by the script file

  7272 	// Each test step initialises it's own name

  7273 	iTestStepName = _L("MM-MMF-ACOD-U-0136-HP");

  7275 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EDstNotFilled;

  7276 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EDstNotFilled;

  7277 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EDstNotFilled;

  7278 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessIncomplete;

  7279 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EDstNotFilled;

  7280 	}

  7282 /** @xxxx

  7283  * PCM16 to IMAD Pass in default sized buffers

  7284  * @test Req. under test REQ172.6.4, REQ172.6.5

  7285  */

  7286 TVerdict CTest_MMF_ACOD_U_0136::DoTestStepL()

  7287 	{

  7288 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

  7289 	TBool testOK = EFalse;

  7290 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize, 0, EFalse));

  7292 	if (err)

  7293 		{

  7294 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7295 		return EFail;

  7296 		}

  7297 	else if (!testOK)

  7298 		{

  7299 		INFO_PRINTF1(_L("Test failed"));

  7300 		return EFail;

  7301 		}

  7302 	else

  7303 		return EPass;

  7304 	}

  7306 //------------------------------------------------------------------

  7308 /** @xxxx

  7309  * Constructor

  7310  */

  7311 CTest_MMF_ACOD_U_0137::CTest_MMF_ACOD_U_0137()

  7312 	{

  7313 	// store the name of this test case

  7314 	// this is the name that is used by the script file

  7315 	// Each test step initialises it's own name

  7316 	iTestStepName = _L("MM-MMF-ACOD-U-0137-HP");

  7318 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EDstNotFilled;

  7319 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EDstNotFilled;

  7320 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EDstNotFilled;

  7321 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessIncomplete;

  7322 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EDstNotFilled;

  7323 	}

  7325 /** @xxxx

  7326  * PCM16 to IMAD Pass in buffers with different max length and length

  7327  * @test Req. under test REQ172.6.4, REQ172.6.5

  7328  */

  7329 TVerdict CTest_MMF_ACOD_U_0137::DoTestStepL()

  7330 	{

  7331 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

  7332 	TBool testOK = EFalse;

  7333 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize, EFalse));

  7335 	if (err)

  7336 		{

  7337 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7338 		return EFail;

  7339 		}

  7340 	else if (!testOK)

  7341 		{

  7342 		INFO_PRINTF1(_L("Test failed"));

  7343 		return EFail;

  7344 		}

  7345 	else

  7346 		return EPass;

  7347 	}

  7349 //------------------------------------------------------------------

  7351 /** @xxxx

  7352  * Constructor

  7353  */

  7354 CTest_MMF_ACOD_U_0138::CTest_MMF_ACOD_U_0138()

  7355 	{

  7356 	// store the name of this test case

  7357 	// this is the name that is used by the script file

  7358 	// Each test step initialises it's own name

  7359 	iTestStepName = _L("MM-MMF-ACOD-U-0138-HP");

  7361 	for (TUint i=0; i<5; i++)

  7362 		{

  7363 		iExpectedSrcBytesProcessed[i] = 0xFC8;

  7364 		iExpectedDstBytesAdded[i] = 0x400;

  7365 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  7366 		}

  7367 	}

  7369 /** @xxxx

  7370  * PCM16 to IMAD Pass in buffers of optimum size

  7371  * @test Req. under test REQ172.6.4, REQ172.6.5

  7372  */

  7373 TVerdict CTest_MMF_ACOD_U_0138::DoTestStepL()

  7374 	{

  7375 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

  7376 	TBool testOK = EFalse;

  7377 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToAdpcmOptimumSrc, KPCM16ToAdpcmOptimumDst));

  7379 	if (err)

  7380 		{

  7381 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7382 		return EFail;

  7383 		}

  7384 	else if (!testOK)

  7385 		{

  7386 		INFO_PRINTF1(_L("Test failed"));

  7387 		return EFail;

  7388 		}

  7389 	else

  7390 		return EPass;

  7391 	}

  7393 //------------------------------------------------------------------

  7395 /** @xxxx

  7396  * Constructor

  7397  */

  7398 CTest_MMF_ACOD_U_0139::CTest_MMF_ACOD_U_0139()

  7399 	{

  7400 	// store the name of this test case

  7401 	// this is the name that is used by the script file

  7402 	// Each test step initialises it's own name

  7403 	iTestStepName = _L("MM-MMF-ACOD-U-0139-HP");

  7404 	}

  7406 /** @xxxx

  7407  * PCM16 to IMAD Reposition source pointer during conversion

  7408  * @test Req. under test REQ172.11

  7409  */

  7410 TVerdict CTest_MMF_ACOD_U_0139::DoTestStepL()

  7411 	{

  7412 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

  7413 	TBool testOK = EFalse;

  7415 	TUint src = (KPCM16ToAdpcmOptimumSrc/4) + 10;

  7417 	INFO_PRINTF1(_L(">> The PCM16 to IMAD codec stores data between calls to ProcessL"));

  7418 	TRAPD(err, testOK = TestRepositionL(codecUid, src, KPCM16ToAdpcmOptimumDst));

  7420 	if (err)

  7421 		{

  7422 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7423 		return EFail;

  7424 		}

  7425 	else if (!testOK)

  7426 		{

  7427 		INFO_PRINTF1(_L("Test failed"));

  7428 		return EFail;

  7429 		}

  7430 	else

  7431 		return EPass;

  7432 	}

  7434 //------------------------------------------------------------------

  7436 /** @xxxx

  7437  * Constructor

  7438  */

  7439 CTest_MMF_ACOD_U_0140::CTest_MMF_ACOD_U_0140()

  7440 	{

  7441 	// store the name of this test case

  7442 	// this is the name that is used by the script file

  7443 	// Each test step initialises it's own name

  7444 	iTestStepName = _L("MM-MMF-ACOD-U-0140-HP");

  7445 	}

  7447 /** @xxxx

  7448  * IMAS to PCM16 Instantiate codec by FourCC Codes

  7449  * @test Req. under test REQ172.6.2, REQ172.11.17

  7450  */

  7451 TVerdict CTest_MMF_ACOD_U_0140::DoTestStepL()

  7452 	{

  7453 	TBool testOK = EFalse;

  7454 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodeIMAS, KMMFFourCCCodePCM16));

  7456 	if (err)

  7457 		{

  7458 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7459 		return EFail;

  7460 		}

  7461 	else if (!testOK)

  7462 		{

  7463 		INFO_PRINTF1(_L("Test failed"));

  7464 		return EFail;

  7465 		}

  7466 	else

  7467 		return EPass;

  7468 	}

  7470 //------------------------------------------------------------------

  7472 /** @xxxx

  7473  * Constructor

  7474  */

  7475 CTest_MMF_ACOD_U_0141::CTest_MMF_ACOD_U_0141()

  7476 	{

  7477 	// store the name of this test case

  7478 	// this is the name that is used by the script file

  7479 	// Each test step initialises it's own name

  7480 	iTestStepName = _L("MM-MMF-ACOD-U-0141-HP");

  7481 	}

  7483 /** @xxxx

  7484  * IMAS to PCM16 Instantiate codec by UID

  7485  * @test Req. under test REQ172.6.1, REQ172.11.17

  7486  */

  7487 TVerdict CTest_MMF_ACOD_U_0141::DoTestStepL()

  7488 	{

  7489 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

  7490 	TBool testOK = EFalse;

  7491 	TRAPD(err, testOK = TestNewL(codecUid));

  7493 	if (err)

  7494 		{

  7495 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7496 		return EFail;

  7497 		}

  7498 	else if (!testOK)

  7499 		{

  7500 		INFO_PRINTF1(_L("Test failed"));

  7501 		return EFail;

  7502 		}

  7503 	else

  7504 		return EPass;

  7505 	}

  7507 //------------------------------------------------------------------

  7509 /** @xxxx

  7510  * Constructor

  7511  */

  7512 CTest_MMF_ACOD_U_0142::CTest_MMF_ACOD_U_0142()

  7513 	{

  7514 	// store the name of this test case

  7515 	// this is the name that is used by the script file

  7516 	// Each test step initialises it's own name

  7517 	iTestStepName = _L("MM-MMF-ACOD-U-0142-HP");

  7519 	for (TUint i=0; i<5; i++)

  7520 		{

  7521 		iExpectedSrcBytesProcessed[i] = 50;

  7522 		iExpectedDstBytesAdded[i] = 0;

  7523 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  7524 		}

  7525 	}

  7527 /** @xxxx

  7528  * IMAS to PCM16 Pass in small source buffers

  7529  * @test Req. under test REQ172.6.4, REQ172.6.5

  7530  */

  7531 TVerdict CTest_MMF_ACOD_U_0142::DoTestStepL()

  7532 	{

  7533 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

  7534 	TBool testOK = EFalse;

  7535 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KStereoAdpcmToPCM16OptimumDst));

  7537 	if (err)

  7538 		{

  7539 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7540 		return EFail;

  7541 		}

  7542 	else if (!testOK)

  7543 		{

  7544 		INFO_PRINTF1(_L("Test failed"));

  7545 		return EFail;

  7546 		}

  7547 	else

  7548 		return EPass;

  7549 	}

  7551 //------------------------------------------------------------------

  7553 /** @xxxx

  7554  * Constructor

  7555  */

  7556 CTest_MMF_ACOD_U_0143::CTest_MMF_ACOD_U_0143()

  7557 	{

  7558 	// store the name of this test case

  7559 	// this is the name that is used by the script file

  7560 	// Each test step initialises it's own name

  7561 	iTestStepName = _L("MM-MMF-ACOD-U-0143-HP");

  7563 	iExpectedLeaveErrorCode = KErrArgument;

  7564 	}

  7566 /** @xxxx

  7567  * IMAS to PCM16 Pass in small dest buffers

  7568  * @test Req. under test REQ172.6.4, REQ172.6.5

  7569  */

  7570 TVerdict CTest_MMF_ACOD_U_0143::DoTestStepL()

  7571 	{

  7572 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

  7573 	TBool testOK = EFalse;

  7574 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KStereoAdpcmToPCM16OptimumSrc, KSmallBufferSize));

  7576 	if (err)

  7577 		{

  7578 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7579 		return EFail;

  7580 		}

  7581 	else if (!testOK)

  7582 		{

  7583 		INFO_PRINTF1(_L("Test failed"));

  7584 		return EFail;

  7585 		}

  7586 	else

  7587 		return EPass;

  7588 	}

  7590 //------------------------------------------------------------------

  7592 /** @xxxx

  7593  * Constructor

  7594  */

  7595 CTest_MMF_ACOD_U_0144::CTest_MMF_ACOD_U_0144()

  7596 	{

  7597 	// store the name of this test case

  7598 	// this is the name that is used by the script file

  7599 	// Each test step initialises it's own name

  7600 	iTestStepName = _L("MM-MMF-ACOD-U-0144-HP");

  7601 	iHeapSize = 0x20000;

  7602 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EProcessIncomplete;

  7603 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EProcessIncomplete;

  7604 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EProcessIncomplete;

  7605 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EDstNotFilled;

  7606 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EProcessIncomplete;

  7607 	}

  7609 /** @xxxx

  7610  * IMAS to PCM16 Pass in large buffers

  7611  * @test Req. under test REQ172.6.4, REQ172.6.5

  7612  */

  7613 TVerdict CTest_MMF_ACOD_U_0144::DoTestStepL()

  7614 	{

  7615 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

  7616 	TBool testOK = EFalse;

  7617 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize, 0, EFalse));

  7619 	if (err)

  7620 		{

  7621 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7622 		return EFail;

  7623 		}

  7624 	else if (!testOK)

  7625 		{

  7626 		INFO_PRINTF1(_L("Test failed"));

  7627 		return EFail;

  7628 		}

  7629 	else

  7630 		return EPass;

  7631 	}

  7633 //------------------------------------------------------------------

  7635 /** @xxxx

  7636  * Constructor

  7637  */

  7638 CTest_MMF_ACOD_U_0145::CTest_MMF_ACOD_U_0145()

  7639 	{

  7640 	// store the name of this test case

  7641 	// this is the name that is used by the script file

  7642 	// Each test step initialises it's own name

  7643 	iTestStepName = _L("MM-MMF-ACOD-U-0145-HP");

  7645 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EProcessIncomplete;

  7646 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EProcessIncomplete;

  7647 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EProcessIncomplete;

  7648 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessComplete;

  7649 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EProcessIncomplete;

  7650 	}

  7652 /** @xxxx

  7653  * IMAS to PCM16 Pass in default sized buffers

  7654  * @test Req. under test REQ172.6.4, REQ172.6.5

  7655  */

  7656 TVerdict CTest_MMF_ACOD_U_0145::DoTestStepL()

  7657 	{

  7658 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

  7659 	TBool testOK = EFalse;

  7660 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize, 0, EFalse));

  7662 	if (err)

  7663 		{

  7664 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7665 		return EFail;

  7666 		}

  7667 	else if (!testOK)

  7668 		{

  7669 		INFO_PRINTF1(_L("Test failed"));

  7670 		return EFail;

  7671 		}

  7672 	else

  7673 		return EPass;

  7674 	}

  7676 //------------------------------------------------------------------

  7678 /** @xxxx

  7679  * Constructor

  7680  */

  7681 CTest_MMF_ACOD_U_0146::CTest_MMF_ACOD_U_0146()

  7682 	{

  7683 	// store the name of this test case

  7684 	// this is the name that is used by the script file

  7685 	// Each test step initialises it's own name

  7686 	iTestStepName = _L("MM-MMF-ACOD-U-0146-HP");

  7688 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EProcessIncomplete;

  7689 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EProcessIncomplete;

  7690 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EProcessIncomplete;

  7691 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessComplete;

  7692 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EProcessIncomplete;

  7693 	}

  7695 /** @xxxx

  7696  * IMAS to PCM16 Pass in buffers with different max length and length

  7697  * @test Req. under test REQ172.6.4, REQ172.6.5

  7698  */

  7699 TVerdict CTest_MMF_ACOD_U_0146::DoTestStepL()

  7700 	{

  7701 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

  7702 	TBool testOK = EFalse;

  7703 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize, EFalse));

  7705 	if (err)

  7706 		{

  7707 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7708 		return EFail;

  7709 		}

  7710 	else if (!testOK)

  7711 		{

  7712 		INFO_PRINTF1(_L("Test failed"));

  7713 		return EFail;

  7714 		}

  7715 	else

  7716 		return EPass;

  7717 	}

  7719 //------------------------------------------------------------------

  7721 /** @xxxx

  7722  * Constructor

  7723  */

  7724 CTest_MMF_ACOD_U_0147::CTest_MMF_ACOD_U_0147()

  7725 	{

  7726 	// store the name of this test case

  7727 	// this is the name that is used by the script file

  7728 	// Each test step initialises it's own name

  7729 	iTestStepName = _L("MM-MMF-ACOD-U-0147-HP");

  7731 	for (TUint i=0; i<5; i++)

  7732 		{

  7733 		iExpectedSrcBytesProcessed[i] = 0x400;

  7734 		iExpectedDstBytesAdded[i] = 0xF90;

  7735 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  7736 		}

  7737 	}

  7739 /** @xxxx

  7740  * IMAS to PCM16 Pass in buffers of optimum size

  7741  * @test Req. under test REQ172.6.4, REQ172.6.5

  7742  */

  7743 TVerdict CTest_MMF_ACOD_U_0147::DoTestStepL()

  7744 	{

  7745 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

  7746 	TBool testOK = EFalse;

  7747 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KStereoAdpcmToPCM16OptimumSrc, KStereoAdpcmToPCM16OptimumDst));

  7749 	if (err)

  7750 		{

  7751 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7752 		return EFail;

  7753 		}

  7754 	else if (!testOK)

  7755 		{

  7756 		INFO_PRINTF1(_L("Test failed"));

  7757 		return EFail;

  7758 		}

  7759 	else

  7760 		return EPass;

  7761 	}

  7763 //------------------------------------------------------------------

  7765 /** @xxxx

  7766  * Constructor

  7767  */

  7768 CTest_MMF_ACOD_U_0148::CTest_MMF_ACOD_U_0148()

  7769 	{

  7770 	// store the name of this test case

  7771 	// this is the name that is used by the script file

  7772 	// Each test step initialises it's own name

  7773 	iTestStepName = _L("MM-MMF-ACOD-U-0148-HP");

  7774 	}

  7776 /** @xxxx

  7777  * IMAS to PCM16 Reposition source pointer during conversion

  7778  * @test Req. under test REQ172.11

  7779  */

  7780 TVerdict CTest_MMF_ACOD_U_0148::DoTestStepL()

  7781 	{

  7782 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

  7783 	TBool testOK = EFalse;

  7785 	TUint src = (KStereoAdpcmToPCM16OptimumSrc/4) + 10;

  7787 	INFO_PRINTF1(_L(">> The IMAS to PCM16 codec stores data between calls to ProcessL"));

  7788 	TRAPD(err, testOK = TestRepositionL(codecUid, src, KStereoAdpcmToPCM16OptimumDst));

  7790 	if (err)

  7791 		{

  7792 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7793 		return EFail;

  7794 		}

  7795 	else if (!testOK)

  7796 		{

  7797 		INFO_PRINTF1(_L("Test failed"));

  7798 		return EFail;

  7799 		}

  7800 	else

  7801 		return EPass;

  7802 	}

  7804 //------------------------------------------------------------------

  7806 /** @xxxx

  7807  * Constructor

  7808  */

  7809 CTest_MMF_ACOD_U_0149::CTest_MMF_ACOD_U_0149()

  7810 	{

  7811 	// store the name of this test case

  7812 	// this is the name that is used by the script file

  7813 	// Each test step initialises it's own name

  7814 	iTestStepName = _L("MM-MMF-ACOD-U-0149-HP");

  7815 	}

  7817 /** @xxxx

  7818  *  PCM16 to IMAS Instantiate codec by FourCC Codes

  7819  * @test Req. under test REQ172.6.2, REQ172.11.18

  7820  */

  7821 TVerdict CTest_MMF_ACOD_U_0149::DoTestStepL()

  7822 	{

  7823 	TBool testOK = EFalse;

  7824 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodeIMAS));

  7826 	if (err)

  7827 		{

  7828 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7829 		return EFail;

  7830 		}

  7831 	else if (!testOK)

  7832 		{

  7833 		INFO_PRINTF1(_L("Test failed"));

  7834 		return EFail;

  7835 		}

  7836 	else

  7837 		return EPass;

  7838 	}

  7840 //------------------------------------------------------------------

  7842 /** @xxxx

  7843  * Constructor

  7844  */

  7845 CTest_MMF_ACOD_U_0150::CTest_MMF_ACOD_U_0150()

  7846 	{

  7847 	// store the name of this test case

  7848 	// this is the name that is used by the script file

  7849 	// Each test step initialises it's own name

  7850 	iTestStepName = _L("MM-MMF-ACOD-U-0150-HP");

  7851 	}

  7853 /** @xxxx

  7854  * PCM16 to IMAS Instantiate codec by UID

  7855  * @test Req. under test REQ172.6.1, REQ172.11.18

  7856  */

  7857 TVerdict CTest_MMF_ACOD_U_0150::DoTestStepL()

  7858 	{

  7859 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

  7860 	TBool testOK = EFalse;

  7861 	TRAPD(err, testOK = TestNewL(codecUid));

  7863 	if (err)

  7864 		{

  7865 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7866 		return EFail;

  7867 		}

  7868 	else if (!testOK)

  7869 		{

  7870 		INFO_PRINTF1(_L("Test failed"));

  7871 		return EFail;

  7872 		}

  7873 	else

  7874 		return EPass;

  7875 	}

  7877 //------------------------------------------------------------------

  7879 /** @xxxx

  7880  * Constructor

  7881  */

  7882 CTest_MMF_ACOD_U_0151::CTest_MMF_ACOD_U_0151()

  7883 	{

  7884 	// store the name of this test case

  7885 	// this is the name that is used by the script file

  7886 	// Each test step initialises it's own name

  7887 	iTestStepName = _L("MM-MMF-ACOD-U-0151-HP");

  7889 	for (TUint i=0; i<5; i++)

  7890 		{

  7891 		iExpectedSrcBytesProcessed[i] = 50;

  7892 		iExpectedDstBytesAdded[i] = 0;

  7893 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  7894 		}

  7895 	}

  7897 /** @xxxx

  7898  * IMAS to PCM16 Pass in small source buffers

  7899  * @test Req. under test REQ172.6.4, REQ172.6.5

  7900  */

  7901 TVerdict CTest_MMF_ACOD_U_0151::DoTestStepL()

  7902 	{

  7903 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

  7904 	TBool testOK = EFalse;

  7905 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSize, KPCM16ToStereoAdpcmOptimumDst));

  7907 	if (err)

  7908 		{

  7909 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7910 		return EFail;

  7911 		}

  7912 	else if (!testOK)

  7913 		{

  7914 		INFO_PRINTF1(_L("Test failed"));

  7915 		return EFail;

  7916 		}

  7917 	else

  7918 		return EPass;

  7919 	}

  7921 //------------------------------------------------------------------

  7923 /** @xxxx

  7924  * Constructor

  7925  */

  7926 CTest_MMF_ACOD_U_0152::CTest_MMF_ACOD_U_0152()

  7927 	{

  7928 	// store the name of this test case

  7929 	// this is the name that is used by the script file

  7930 	// Each test step initialises it's own name

  7931 	iTestStepName = _L("MM-MMF-ACOD-U-0152-HP");

  7933 	iExpectedLeaveErrorCode = KErrArgument;

  7934 	}

  7936 /** @xxxx

  7937  * PCM16 to IMAS Pass in small dest buffers

  7938  * @test Req. under test REQ172.6.4, REQ172.6.5

  7939  */

  7940 TVerdict CTest_MMF_ACOD_U_0152::DoTestStepL()

  7941 	{

  7942 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

  7943 	TBool testOK = EFalse;

  7944 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToStereoAdpcmOptimumSrc, KSmallBufferSize));

  7946 	if (err)

  7947 		{

  7948 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7949 		return EFail;

  7950 		}

  7951 	else if (!testOK)

  7952 		{

  7953 		INFO_PRINTF1(_L("Test failed"));

  7954 		return EFail;

  7955 		}

  7956 	else

  7957 		return EPass;

  7958 	}

  7960 //------------------------------------------------------------------

  7962 /** @xxxx

  7963  * Constructor

  7964  */

  7965 CTest_MMF_ACOD_U_0153::CTest_MMF_ACOD_U_0153()

  7966 	{

  7967 	// store the name of this test case

  7968 	// this is the name that is used by the script file

  7969 	// Each test step initialises it's own name

  7970 	iTestStepName = _L("MM-MMF-ACOD-U-0153-HP");

  7971 	iHeapSize = 0x20000;

  7972 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EDstNotFilled;

  7973 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EDstNotFilled;

  7974 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EDstNotFilled;

  7975 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessIncomplete;

  7976 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EDstNotFilled;

  7977 	}

  7979 /** @xxxx

  7980  * PCM16 to IMAS Pass in large buffers

  7981  * @test Req. under test REQ172.6.4, REQ172.6.5

  7982  */

  7983 TVerdict CTest_MMF_ACOD_U_0153::DoTestStepL()

  7984 	{

  7985 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

  7986 	TBool testOK = EFalse;

  7987 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize, 0, EFalse));

  7989 	if (err)

  7990 		{

  7991 		INFO_PRINTF2(_L("Test left with status %d"), err);

  7992 		return EFail;

  7993 		}

  7994 	else if (!testOK)

  7995 		{

  7996 		INFO_PRINTF1(_L("Test failed"));

  7997 		return EFail;

  7998 		}

  7999 	else

  8000 		return EPass;

  8001 	}

  8003 //------------------------------------------------------------------

  8005 /** @xxxx

  8006  * Constructor

  8007  */

  8008 CTest_MMF_ACOD_U_0154::CTest_MMF_ACOD_U_0154()

  8009 	{

  8010 	// store the name of this test case

  8011 	// this is the name that is used by the script file

  8012 	// Each test step initialises it's own name

  8013 	iTestStepName = _L("MM-MMF-ACOD-U-0154-HP");

  8015 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EDstNotFilled;

  8016 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EDstNotFilled;

  8017 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EDstNotFilled;

  8018 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessComplete;

  8019 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EDstNotFilled;

  8020 	}

  8022 /** @xxxx

  8023  * PCM16 to IMAS Pass in default sized buffers

  8024  * @test Req. under test REQ172.6.4, REQ172.6.5

  8025  */

  8026 TVerdict CTest_MMF_ACOD_U_0154::DoTestStepL()

  8027 	{

  8028 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

  8029 	TBool testOK = EFalse;

  8030 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize, 0, EFalse));

  8032 	if (err)

  8033 		{

  8034 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8035 		return EFail;

  8036 		}

  8037 	else if (!testOK)

  8038 		{

  8039 		INFO_PRINTF1(_L("Test failed"));

  8040 		return EFail;

  8041 		}

  8042 	else

  8043 		return EPass;

  8044 	}

  8046 //------------------------------------------------------------------

  8048 /** @xxxx

  8049  * Constructor

  8050  */

  8051 CTest_MMF_ACOD_U_0155::CTest_MMF_ACOD_U_0155()

  8052 	{

  8053 	// store the name of this test case

  8054 	// this is the name that is used by the script file

  8055 	// Each test step initialises it's own name

  8056 	iTestStepName = _L("MM-MMF-ACOD-U-0155-HP");

  8058 	iExpectedReturnValue[0].iStatus = TCodecProcessResult::EDstNotFilled;

  8059 	iExpectedReturnValue[1].iStatus = TCodecProcessResult::EDstNotFilled;

  8060 	iExpectedReturnValue[2].iStatus = TCodecProcessResult::EDstNotFilled;

  8061 	iExpectedReturnValue[3].iStatus = TCodecProcessResult::EProcessComplete;

  8062 	iExpectedReturnValue[4].iStatus = TCodecProcessResult::EDstNotFilled;

  8063 	}

  8065 /** @xxxx

  8066  * PCM16 to IMAS Pass in buffers with different max length and length

  8067  * @test Req. under test REQ172.6.4, REQ172.6.5

  8068  */

  8069 TVerdict CTest_MMF_ACOD_U_0155::DoTestStepL()

  8070 	{

  8071 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

  8072 	TBool testOK = EFalse;

  8073 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize, EFalse));

  8075 	if (err)

  8076 		{

  8077 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8078 		return EFail;

  8079 		}

  8080 	else if (!testOK)

  8081 		{

  8082 		INFO_PRINTF1(_L("Test failed"));

  8083 		return EFail;

  8084 		}

  8085 	else

  8086 		return EPass;

  8087 	}

  8089 //------------------------------------------------------------------

  8091 /** @xxxx

  8092  * Constructor

  8093  */

  8094 CTest_MMF_ACOD_U_0156::CTest_MMF_ACOD_U_0156()

  8095 	{

  8096 	// store the name of this test case

  8097 	// this is the name that is used by the script file

  8098 	// Each test step initialises it's own name

  8099 	iTestStepName = _L("MM-MMF-ACOD-U-0156-HP");

  8101 	for (TUint i=0; i<5; i++)

  8102 		{

  8103 		iExpectedSrcBytesProcessed[i] = 0xF90;

  8104 		iExpectedDstBytesAdded[i] = 0x400;

  8105 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  8106 		}

  8107 	}

  8109 /** @xxxx

  8110  * PCM16 to IMAS Pass in buffers of optimum size

  8111  * @test Req. under test REQ172.6.4, REQ172.6.5

  8112  */

  8113 TVerdict CTest_MMF_ACOD_U_0156::DoTestStepL()

  8114 	{

  8115 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

  8116 	TBool testOK = EFalse;

  8117 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToStereoAdpcmOptimumSrc, KPCM16ToStereoAdpcmOptimumDst));

  8119 	if (err)

  8120 		{

  8121 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8122 		return EFail;

  8123 		}

  8124 	else if (!testOK)

  8125 		{

  8126 		INFO_PRINTF1(_L("Test failed"));

  8127 		return EFail;

  8128 		}

  8129 	else

  8130 		return EPass;

  8131 	}

  8133 //------------------------------------------------------------------

  8135 /** @xxxx

  8136  * Constructor

  8137  */

  8138 CTest_MMF_ACOD_U_0157::CTest_MMF_ACOD_U_0157()

  8139 	{

  8140 	// store the name of this test case

  8141 	// this is the name that is used by the script file

  8142 	// Each test step initialises it's own name

  8143 	iTestStepName = _L("MM-MMF-ACOD-U-0157-HP");

  8144 	}

  8146 /** @xxxx

  8147  * PCM16 to IMAS Reposition source pointer during conversion

  8148  * @test Req. under test REQ172.11

  8149  */

  8150 TVerdict CTest_MMF_ACOD_U_0157::DoTestStepL()

  8151 	{

  8152 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

  8153 	TBool testOK = EFalse;

  8155 	TUint src = (KPCM16ToStereoAdpcmOptimumSrc/4) + 10;

  8157 	INFO_PRINTF1(_L(">> The PCM16 to IMAS codec stores data between calls to ProcessL"));

  8158 	TRAPD(err, testOK = TestRepositionL(codecUid, src, KPCM16ToStereoAdpcmOptimumDst));

  8160 	if (err)

  8161 		{

  8162 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8163 		return EFail;

  8164 		}

  8165 	else if (!testOK)

  8166 		{

  8167 		INFO_PRINTF1(_L("Test failed"));

  8168 		return EFail;

  8169 		}

  8170 	else

  8171 		return EPass;

  8172 	}

  8174 //------------------------------------------------------------------

  8176 /** @xxxx

  8177  * Constructor

  8178  */

  8179 CTest_MMF_ACOD_U_0158::CTest_MMF_ACOD_U_0158()

  8180 	{

  8181 	// store the name of this test case

  8182 	// this is the name that is used by the script file

  8183 	// Each test step initialises it's own name

  8184 	iTestStepName = _L("MM-MMF-ACOD-U-0158-HP");

  8185 	}

  8187 /** @xxxx

  8188  * GSM610 to PCM16 Instantiate codec by FourCC Codes

  8189  * @test Req. under test REQ172.6.2, REQ172.11.19

  8190  */

  8191 TVerdict CTest_MMF_ACOD_U_0158::DoTestStepL()

  8192 	{

  8193 	TBool testOK = EFalse;

  8194 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodeGSM610, KMMFFourCCCodePCM16));

  8196 	if (err)

  8197 		{

  8198 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8199 		return EFail;

  8200 		}

  8201 	else if (!testOK)

  8202 		{

  8203 		INFO_PRINTF1(_L("Test failed"));

  8204 		return EFail;

  8205 		}

  8206 	else

  8207 		return EPass;

  8208 	}

  8210 //------------------------------------------------------------------

  8212 /** @xxxx

  8213  * Constructor

  8214  */

  8215 CTest_MMF_ACOD_U_0159::CTest_MMF_ACOD_U_0159()

  8216 	{

  8217 	// store the name of this test case

  8218 	// this is the name that is used by the script file

  8219 	// Each test step initialises it's own name

  8220 	iTestStepName = _L("MM-MMF-ACOD-U-0159-HP");

  8221 	}

  8223 /** @xxxx

  8224  * GSM610 to PCM16 Instantiate codec by UID

  8225  * @test Req. under test REQ172.6.1, REQ172.11.19

  8226  */

  8227 TVerdict CTest_MMF_ACOD_U_0159::DoTestStepL()

  8228 	{

  8229 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

  8230 	TBool testOK = EFalse;

  8231 	TRAPD(err, testOK = TestNewL(codecUid));

  8233 	if (err)

  8234 		{

  8235 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8236 		return EFail;

  8237 		}

  8238 	else if (!testOK)

  8239 		{

  8240 		INFO_PRINTF1(_L("Test failed"));

  8241 		return EFail;

  8242 		}

  8243 	else

  8244 		return EPass;

  8245 	}

  8247 //------------------------------------------------------------------

  8249 /** @xxxx

  8250  * Constructor

  8251  */

  8252 CTest_MMF_ACOD_U_0160::CTest_MMF_ACOD_U_0160()

  8253 	{

  8254 	// store the name of this test case

  8255 	// this is the name that is used by the script file

  8256 	// Each test step initialises it's own name

  8257 	iTestStepName = _L("MM-MMF-ACOD-U-0160-HP");

  8258 	iHeapSize = 0x200000;

  8260 	for (TUint i=0; i<5; i++)

  8261 		{

  8262 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  8263 		}

  8265 	}

  8267 /** @xxxx

  8268  * GSM610 to PCM16 Pass in small source buffers

  8269  * @test Req. under test REQ172.6.4, REQ172.6.5

  8270  */

  8271 TVerdict CTest_MMF_ACOD_U_0160::DoTestStepL()

  8272 	{

  8273 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

  8274 	TBool testOK = EFalse;

  8275 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSizeGSM, KGSM610ToPCM16OptimumDstGSM, 0, EFalse));

  8277 	if (err)

  8278 		{

  8279 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8280 		return EFail;

  8281 		}

  8282 	else if (!testOK)

  8283 		{

  8284 		INFO_PRINTF1(_L("Test failed"));

  8285 		return EFail;

  8286 		}

  8287 	else

  8288 		return EPass;

  8289 	}

  8291 //------------------------------------------------------------------

  8293 /** @xxxx

  8294  * Constructor

  8295  */

  8296 CTest_MMF_ACOD_U_0161::CTest_MMF_ACOD_U_0161()

  8297 	{

  8298 	// store the name of this test case

  8299 	// this is the name that is used by the script file

  8300 	// Each test step initialises it's own name

  8301 	iTestStepName = _L("MM-MMF-ACOD-U-0161-HP");

  8302 	iHeapSize = 0x20000;

  8304 	for (TUint i=0; i<5; i++)

  8305 		{

  8306 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  8307 		}

  8308 	}

  8310 /** @xxxx

  8311  * GSM610 to PCM16 Pass in small dest buffers

  8312  * @test Req. under test REQ172.6.4, REQ172.6.5

  8313  */

  8314 TVerdict CTest_MMF_ACOD_U_0161::DoTestStepL()

  8315 	{

  8316 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

  8317 	TBool testOK = EFalse;

  8318 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KGSM610ToPCM16OptimumSrcGSM, KSmallBufferSizeGSM, 0, EFalse));

  8320 	if (err)

  8321 		{

  8322 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8323 		return EFail;

  8324 		}

  8325 	else if (!testOK)

  8326 		{

  8327 		INFO_PRINTF1(_L("Test failed"));

  8328 		return EFail;

  8329 		}

  8330 	else

  8331 		return EPass;

  8332 	}

  8334 //------------------------------------------------------------------

  8336 /** @xxxx

  8337  * Constructor

  8338  */

  8339 CTest_MMF_ACOD_U_0162::CTest_MMF_ACOD_U_0162()

  8340 	{

  8341 	// store the name of this test case

  8342 	// this is the name that is used by the script file

  8343 	// Each test step initialises it's own name

  8344 	iTestStepName = _L("MM-MMF-ACOD-U-0162-HP");

  8345 	iHeapSize = 0x20000;

  8346 	for (TUint i=0; i<5; i++)

  8347 		{

  8348 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  8349 		}

  8350 	}

  8352 /** @xxxx

  8353  * GSM610 to PCM16 Pass in large buffers

  8354  * @test Req. under test REQ172.6.4, REQ172.6.5

  8355  */

  8356 TVerdict CTest_MMF_ACOD_U_0162::DoTestStepL()

  8357 	{

  8358 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

  8359 	TBool testOK = EFalse;

  8360 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize, 0, EFalse));

  8362 	if (err)

  8363 		{

  8364 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8365 		return EFail;

  8366 		}

  8367 	else if (!testOK)

  8368 		{

  8369 		INFO_PRINTF1(_L("Test failed"));

  8370 		return EFail;

  8371 		}

  8372 	else

  8373 		return EPass;

  8374 	}

  8376 //------------------------------------------------------------------

  8378 /** @xxxx

  8379  * Constructor

  8380  */

  8381 CTest_MMF_ACOD_U_0163::CTest_MMF_ACOD_U_0163()

  8382 	{

  8383 	// store the name of this test case

  8384 	// this is the name that is used by the script file

  8385 	// Each test step initialises it's own name

  8386 	iTestStepName = _L("MM-MMF-ACOD-U-0163-HP");

  8388 	for (TUint i=0; i<5; i++)

  8389 		{

  8390 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  8391 		}

  8392 	}

  8394 /** @xxxx

  8395  * GSM610 to PCM16 Pass in default sized buffers

  8396  * @test Req. under test REQ172.6.4, REQ172.6.5

  8397  */

  8398 TVerdict CTest_MMF_ACOD_U_0163::DoTestStepL()

  8399 	{

  8400 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

  8401 	TBool testOK = EFalse;

  8402 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize, 0, EFalse));

  8404 	if (err)

  8405 		{

  8406 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8407 		return EFail;

  8408 		}

  8409 	else if (!testOK)

  8410 		{

  8411 		INFO_PRINTF1(_L("Test failed"));

  8412 		return EFail;

  8413 		}

  8414 	else

  8415 		return EPass;

  8416 	}

  8418 //------------------------------------------------------------------

  8420 /** @xxxx

  8421  * Constructor

  8422  */

  8423 CTest_MMF_ACOD_U_0164::CTest_MMF_ACOD_U_0164()

  8424 	{

  8425 	// store the name of this test case

  8426 	// this is the name that is used by the script file

  8427 	// Each test step initialises it's own name

  8428 	iTestStepName = _L("MM-MMF-ACOD-U-0164-HP");

  8430 	for (TUint i=0; i<5; i++)

  8431 		{

  8432 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessIncomplete;

  8433 		}

  8434 	}

  8436 /** @xxxx

  8437  * GSM610 to PCM16 Pass in buffers with different max length and length

  8438  * @test Req. under test REQ172.6.4, REQ172.6.5

  8439  */

  8440 TVerdict CTest_MMF_ACOD_U_0164::DoTestStepL()

  8441 	{

  8442 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

  8443 	TBool testOK = EFalse;

  8444 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize, EFalse));

  8446 	if (err)

  8447 		{

  8448 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8449 		return EFail;

  8450 		}

  8451 	else if (!testOK)

  8452 		{

  8453 		INFO_PRINTF1(_L("Test failed"));

  8454 		return EFail;

  8455 		}

  8456 	else

  8457 		return EPass;

  8458 	}

  8460 //------------------------------------------------------------------

  8462 /** @xxxx

  8463  * Constructor

  8464  */

  8465 CTest_MMF_ACOD_U_0165::CTest_MMF_ACOD_U_0165()

  8466 	{

  8467 	// store the name of this test case

  8468 	// this is the name that is used by the script file

  8469 	// Each test step initialises it's own name

  8470 	iTestStepName = _L("MM-MMF-ACOD-U-0165-HP");

  8471 	iSingleIteration = ETrue;

  8473 	for (TUint i=0; i<5; i++)

  8474 		{

  8475 		iExpectedSrcBytesProcessed[i] = 0x104;

  8476 		iExpectedDstBytesAdded[i] = 0xA00;

  8477 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  8478 		}

  8479 	}

  8481 /** @xxxx

  8482  * GSM610 to PCM16 Pass in buffers of optimum size

  8483  * @test Req. under test REQ172.6.4, REQ172.6.5

  8484  */

  8485 TVerdict CTest_MMF_ACOD_U_0165::DoTestStepL()

  8486 	{

  8487 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

  8488 	TBool testOK = EFalse;

  8489 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KGSM610ToPCM16OptimumSrc, KGSM610ToPCM16OptimumDst));

  8491 	if (err)

  8492 		{

  8493 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8494 		return EFail;

  8495 		}

  8496 	else if (!testOK)

  8497 		{

  8498 		INFO_PRINTF1(_L("Test failed"));

  8499 		return EFail;

  8500 		}

  8501 	else

  8502 		return EPass;

  8503 	}

  8505 //------------------------------------------------------------------

  8507 /** @xxxx

  8508  * Constructor

  8509  */

  8510 CTest_MMF_ACOD_U_0166::CTest_MMF_ACOD_U_0166()

  8511 	{

  8512 	// store the name of this test case

  8513 	// this is the name that is used by the script file

  8514 	// Each test step initialises it's own name

  8515 	iTestStepName = _L("MM-MMF-ACOD-U-0166-HP");

  8516 	}

  8518 /** @xxxx

  8519  * GSM610 to PCM16 Reposition source pointer during conversion

  8520  * @test Req. under test REQ172.11

  8521  */

  8522 TVerdict CTest_MMF_ACOD_U_0166::DoTestStepL()

  8523 	{

  8524 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

  8525 	TBool testOK = EFalse;

  8527 	TUint src = (KGSM610ToPCM16OptimumSrc/4) + 10;

  8529 	INFO_PRINTF1(_L(">> The GSM610 to PCM16 codec stores data between calls to ProcessL"));

  8530 	TRAPD(err, testOK = TestRepositionL(codecUid, src, KGSM610ToPCM16OptimumDst));

  8532 	if (err)

  8533 		{

  8534 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8535 		return EFail;

  8536 		}

  8537 	else if (!testOK)

  8538 		{

  8539 		INFO_PRINTF1(_L("Test failed"));

  8540 		return EFail;

  8541 		}

  8542 	else

  8543 		return EPass;

  8544 	}

  8546 //------------------------------------------------------------------

  8548 /** @xxxx

  8549  * Constructor

  8550  */

  8551 CTest_MMF_ACOD_U_0167::CTest_MMF_ACOD_U_0167()

  8552 	{

  8553 	// store the name of this test case

  8554 	// this is the name that is used by the script file

  8555 	// Each test step initialises it's own name

  8556 	iTestStepName = _L("MM-MMF-ACOD-U-0167-HP");

  8557 	}

  8559 /** @xxxx

  8560  *  PCM16 to GSM610 Instantiate codec by FourCC Codes

  8561  * @test Req. under test REQ172.6.2, REQ172.11.20

  8562  */

  8563 TVerdict CTest_MMF_ACOD_U_0167::DoTestStepL()

  8564 	{

  8565 	TBool testOK = EFalse;

  8566 	TRAPD(err, testOK = TestNewL(KMMFFourCCCodePCM16, KMMFFourCCCodeGSM610));

  8568 	if (err)

  8569 		{

  8570 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8571 		return EFail;

  8572 		}

  8573 	else if (!testOK)

  8574 		{

  8575 		INFO_PRINTF1(_L("Test failed"));

  8576 		return EFail;

  8577 		}

  8578 	else

  8579 		return EPass;

  8580 	}

  8582 //------------------------------------------------------------------

  8584 /** @xxxx

  8585  * Constructor

  8586  */

  8587 CTest_MMF_ACOD_U_0168::CTest_MMF_ACOD_U_0168()

  8588 	{

  8589 	// store the name of this test case

  8590 	// this is the name that is used by the script file

  8591 	// Each test step initialises it's own name

  8592 	iTestStepName = _L("MM-MMF-ACOD-U-0168-HP");

  8593 	}

  8595 /** @xxxx

  8596  * PCM16 to GSM610 Instantiate codec by UID

  8597  * @test Req. under test REQ172.6.1, REQ172.11.20

  8598  */

  8599 TVerdict CTest_MMF_ACOD_U_0168::DoTestStepL()

  8600 	{

  8601 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

  8602 	TBool testOK = EFalse;

  8603 	TRAPD(err, testOK = TestNewL(codecUid));

  8605 	if (err)

  8606 		{

  8607 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8608 		return EFail;

  8609 		}

  8610 	else if (!testOK)

  8611 		{

  8612 		INFO_PRINTF1(_L("Test failed"));

  8613 		return EFail;

  8614 		}

  8615 	else

  8616 		return EPass;

  8617 	}

  8619 //------------------------------------------------------------------

  8621 /** @xxxx

  8622  * Constructor

  8623  */

  8624 CTest_MMF_ACOD_U_0169::CTest_MMF_ACOD_U_0169()

  8625 	{

  8626 	// store the name of this test case

  8627 	// this is the name that is used by the script file

  8628 	// Each test step initialises it's own name

  8629 	iTestStepName = _L("MM-MMF-ACOD-U-0169-HP");

  8630 	iHeapSize = 0x20000;

  8632 	for (TUint i=0; i<5; i++)

  8633 		{

  8634 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  8635 		}

  8636 	}

  8638 /** @xxxx

  8639  * GSM610 to PCM16 Pass in small source buffers

  8640  * @test Req. under test REQ172.6.4, REQ172.6.5

  8641  */

  8642 TVerdict CTest_MMF_ACOD_U_0169::DoTestStepL()

  8643 	{

  8644 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

  8645 	TBool testOK = EFalse;

  8646 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KSmallBufferSizeGSM, KPCM16ToGSM610OptimumDstGSM, 0, EFalse));

  8648 	if (err)

  8649 		{

  8650 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8651 		return EFail;

  8652 		}

  8653 	else if (!testOK)

  8654 		{

  8655 		INFO_PRINTF1(_L("Test failed"));

  8656 		return EFail;

  8657 		}

  8658 	else

  8659 		return EPass;

  8660 	}

  8662 //------------------------------------------------------------------

  8664 /** @xxxx

  8665  * Constructor

  8666  */

  8667 CTest_MMF_ACOD_U_0170::CTest_MMF_ACOD_U_0170()

  8668 	{

  8669 	// store the name of this test case

  8670 	// this is the name that is used by the script file

  8671 	// Each test step initialises it's own name

  8672 	iTestStepName = _L("MM-MMF-ACOD-U-0170-HP");

  8674 	iExpectedLeaveErrorCode = KErrArgument;

  8675 	}

  8677 /** @xxxx

  8678  * PCM16 to GSM610 Pass in small dest buffers

  8679  * @test Req. under test REQ172.6.4, REQ172.6.5

  8680  */

  8681 TVerdict CTest_MMF_ACOD_U_0170::DoTestStepL()

  8682 	{

  8683 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

  8684 	TBool testOK = EFalse;

  8685 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToGSM610OptimumSrc, KSmallBufferSize, 0, EFalse));

  8687 	if (err)

  8688 		{

  8689 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8690 		return EFail;

  8691 		}

  8692 	else if (!testOK)

  8693 		{

  8694 		INFO_PRINTF1(_L("Test failed"));

  8695 		return EFail;

  8696 		}

  8697 	else

  8698 		return EPass;

  8699 	}

  8701 //------------------------------------------------------------------

  8703 /** @xxxx

  8704  * Constructor

  8705  */

  8706 CTest_MMF_ACOD_U_0171::CTest_MMF_ACOD_U_0171()

  8707 	{

  8708 	// store the name of this test case

  8709 	// this is the name that is used by the script file

  8710 	// Each test step initialises it's own name

  8711 	iTestStepName = _L("MM-MMF-ACOD-U-0171-HP");

  8712 	iHeapSize = 0x20000;

  8713 	for (TUint i=0; i<5; i++)

  8714 		{

  8715 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  8716 		}

  8717 	}

  8719 /** @xxxx

  8720  * PCM16 to GSM610 Pass in large buffers

  8721  * @test Req. under test REQ172.6.4, REQ172.6.5

  8722  */

  8723 TVerdict CTest_MMF_ACOD_U_0171::DoTestStepL()

  8724 	{

  8725 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

  8726 	TBool testOK = EFalse;

  8727 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KLargeBufferSize, KLargeBufferSize, 0, EFalse));

  8729 	if (err)

  8730 		{

  8731 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8732 		return EFail;

  8733 		}

  8734 	else if (!testOK)

  8735 		{

  8736 		INFO_PRINTF1(_L("Test failed"));

  8737 		return EFail;

  8738 		}

  8739 	else

  8740 		return EPass;

  8741 	}

  8743 //------------------------------------------------------------------

  8745 /** @xxxx

  8746  * Constructor

  8747  */

  8748 CTest_MMF_ACOD_U_0172::CTest_MMF_ACOD_U_0172()

  8749 	{

  8750 	// store the name of this test case

  8751 	// this is the name that is used by the script file

  8752 	// Each test step initialises it's own name

  8753 	iTestStepName = _L("MM-MMF-ACOD-U-0172-HP");

  8755 	for (TUint i=0; i<5; i++)

  8756 		{

  8757 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  8758 		}

  8759 	}

  8761 /** @xxxx

  8762  * PCM16 to GSM610 Pass in default sized buffers

  8763  * @test Req. under test REQ172.6.4, REQ172.6.5

  8764  */

  8765 TVerdict CTest_MMF_ACOD_U_0172::DoTestStepL()

  8766 	{

  8767 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

  8768 	TBool testOK = EFalse;

  8769 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KDefaultBufferSize, KDefaultBufferSize, 0, EFalse));

  8771 	if (err)

  8772 		{

  8773 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8774 		return EFail;

  8775 		}

  8776 	else if (!testOK)

  8777 		{

  8778 		INFO_PRINTF1(_L("Test failed"));

  8779 		return EFail;

  8780 		}

  8781 	else

  8782 		return EPass;

  8783 	}

  8785 //------------------------------------------------------------------

  8787 /** @xxxx

  8788  * Constructor

  8789  */

  8790 CTest_MMF_ACOD_U_0173::CTest_MMF_ACOD_U_0173()

  8791 	{

  8792 	// store the name of this test case

  8793 	// this is the name that is used by the script file

  8794 	// Each test step initialises it's own name

  8795 	iTestStepName = _L("MM-MMF-ACOD-U-0173-HP");

  8797 	for (TUint i=0; i<5; i++)

  8798 		{

  8799 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  8800 		}

  8801 	}

  8803 /** @xxxx

  8804  * PCM16 to GSM610 Pass in buffers with different max length and length

  8805  * @test Req. under test REQ172.6.4, REQ172.6.5

  8806  */

  8807 TVerdict CTest_MMF_ACOD_U_0173::DoTestStepL()

  8808 	{

  8809 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

  8810 	TBool testOK = EFalse;

  8811 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMaxBufferLength, KDefaultBufferSize, KDefaultBufferSize, EFalse));

  8813 	if (err)

  8814 		{

  8815 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8816 		return EFail;

  8817 		}

  8818 	else if (!testOK)

  8819 		{

  8820 		INFO_PRINTF1(_L("Test failed"));

  8821 		return EFail;

  8822 		}

  8823 	else

  8824 		return EPass;

  8825 	}

  8827 //------------------------------------------------------------------

  8829 /** @xxxx

  8830  * Constructor

  8831  */

  8832 CTest_MMF_ACOD_U_0174::CTest_MMF_ACOD_U_0174()

  8833 	{

  8834 	// store the name of this test case

  8835 	// this is the name that is used by the script file

  8836 	// Each test step initialises it's own name

  8837 	iTestStepName = _L("MM-MMF-ACOD-U-0174-HP");

  8838 	iSingleIteration = ETrue;

  8840 	for (TUint i=0; i<5; i++)

  8841 		{

  8842 		iExpectedSrcBytesProcessed[i] = 0xA00;

  8843 		iExpectedDstBytesAdded[i] = 0x104;

  8844 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EProcessComplete;

  8845 		}

  8846 	}

  8848 /** @xxxx

  8849  * PCM16 to GSM610 Pass in buffers of optimum size

  8850  * @test Req. under test REQ172.6.4, REQ172.6.5

  8851  */

  8852 TVerdict CTest_MMF_ACOD_U_0174::DoTestStepL()

  8853 	{

  8854 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

  8855 	TBool testOK = EFalse;

  8856 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToGSM610OptimumSrc, KPCM16ToGSM610OptimumDst));

  8858 	if (err)

  8859 		{

  8860 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8861 		return EFail;

  8862 		}

  8863 	else if (!testOK)

  8864 		{

  8865 		INFO_PRINTF1(_L("Test failed"));

  8866 		return EFail;

  8867 		}

  8868 	else

  8869 		return EPass;

  8870 	}

  8872 //------------------------------------------------------------------

  8874 /** @xxxx

  8875  * Constructor

  8876  */

  8877 CTest_MMF_ACOD_U_0175::CTest_MMF_ACOD_U_0175()

  8878 	{

  8879 	// store the name of this test case

  8880 	// this is the name that is used by the script file

  8881 	// Each test step initialises it's own name

  8882 	iTestStepName = _L("MM-MMF-ACOD-U-0175-HP");

  8883 	}

  8885 /** @xxxx

  8886  * PCM16 to GSM610 Reposition source pointer during conversion

  8887  * @test Req. under test REQ172.11

  8888  */

  8889 TVerdict CTest_MMF_ACOD_U_0175::DoTestStepL()

  8890 	{

  8891 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

  8892 	TBool testOK = EFalse;

  8894 	TUint src = (KPCM16ToGSM610OptimumSrc/4) + 10;

  8896 	INFO_PRINTF1(_L(">> The PCM16 to GSM610 codec stores data between calls to ProcessL"));

  8897 	TRAPD(err, testOK = TestRepositionL(codecUid, src, KPCM16ToGSM610OptimumDst));

  8899 	if (err)

  8900 		{

  8901 		INFO_PRINTF2(_L("Test left with status %d"), err);

  8902 		return EFail;

  8903 		}

  8904 	else if (!testOK)

  8905 		{

  8906 		INFO_PRINTF1(_L("Test failed"));

  8907 		return EFail;

  8908 		}

  8909 	else

  8910 		return EPass;

  8911 	}

  8913 //------------------------------------------------------------------

  8915 /** @xxxx

  8916  * Constructor

  8917  */

  8918 CTest_MMF_ACOD_U_0176::CTest_MMF_ACOD_U_0176()

  8919 	{

  8920 	// store the name of this test case

  8921 	// this is the name that is used by the script file

  8922 	// Each test step initialises it's own name

  8923 	iTestStepName = _L("MM-MMF-ACOD-U-0176-HP");

  8924 	}

  8926 /** @xxxx

  8927  * Instantiate codec that doesn't exist

  8928  * @test Req. under test REQ172.11

  8929  */

  8930 TVerdict CTest_MMF_ACOD_U_0176::DoTestStepL()

  8931 	{

  8932 //	CMMFCodec* codec = NULL;

  8933 //	TRAPD(err, codec = CMMFCodec::NewL(KMMFFourCCCodeALAW, KMMFFourCCCodePCMU16B));

  8934 	TRAPD(err, CMMFCodec::NewL(KMMFFourCCCodeALAW, KMMFFourCCCodePCMU16B));	// EABI warning removal - "variable was set but never used"

  8936 	if (err == KErrNone || err == KErrNotSupported)

  8937 		return EPass;

  8938 	else

  8939 		{

  8940 		ERR_PRINTF2(_L(">> CTest_MMF_ACOD_U_0176::DoTestStepL Leave occurred in NewL, error code %d"), err);

  8941 		return EFail;

  8942 		}

  8943 	}

  8944 //------------------------------------------------------------------

  8946 /** @xxxx

  8947  * Constructor

  8948  */

  8949 CTest_MMF_ACOD_U_0177::CTest_MMF_ACOD_U_0177()

  8950 	{

  8951 	// store the name of this test case

  8952 	// this is the name that is used by the script file

  8953 	// Each test step initialises it's own name

  8954 	iTestStepName = _L("MM-MMF-ACOD-U-0177-HP");

  8955 	}

  8957 /** @xxxx

  8958  * Instantiate codec from fourCC codes that don't exist

  8959  * @test Req. under test REQ172.11

  8960  */

  8961 TVerdict CTest_MMF_ACOD_U_0177::DoTestStepL()

  8962 	{

  8963 	const TUint32 KFourCCCodeP1B = 0x42315020;		//(' ', 'P', '1', 'B')

  8964 	const TUint32 KFourCCCodePS16 = 0x36315350;		//('P', 'S', '1', '6')

  8966 //	CMMFCodec* codec = NULL;

  8967 //	TRAPD(err, codec = CMMFCodec::NewL(KFourCCCodeP1B, KFourCCCodePS16));

  8968 	TRAPD(err, CMMFCodec::NewL(KFourCCCodeP1B, KFourCCCodePS16));	// EABI warning removal "variable was set but never used"

  8970 	if (err == KErrNone || err == KErrNotSupported)

  8971 		return EPass;

  8972 	else

  8973 		{

  8974 		ERR_PRINTF2(_L(">> CTest_MMF_ACOD_U_0177::DoTestStepL Leave occurred in NewL, error code %d"), err);

  8975 		return EFail;

  8976 		}

  8977 	}

  8978 //------------------------------------------------------------------

  8980 /** @xxxx

  8981  * Constructor

  8982  */

  8983 CTest_MMF_ACOD_U_0178::CTest_MMF_ACOD_U_0178()

  8984 	{

  8985 	// store the name of this test case

  8986 	// this is the name that is used by the script file

  8987 	// Each test step initialises it's own name

  8988 	iTestStepName = _L("MM-MMF-ACOD-U-0178-HP");

  8989 	}

  8991 /** @xxxx

  8992  * Test out of memory in NewL

  8993  * @test Req. under test REQ172.11

  8994  */

  8995 TVerdict CTest_MMF_ACOD_U_0178::DoTestStepL()

  8996 	{

  8997 //	CMMFCodec* codec = NULL;

  8998 	__UHEAP_FAILNEXT(1);

  8999 //	TRAPD(err, codec = CMMFCodec::NewL(KMMFFourCCCodePCMU8, KMMFFourCCCodePCM16));

  9000 	TRAPD(err, CMMFCodec::NewL(KMMFFourCCCodePCMU8, KMMFFourCCCodePCM16));	// EABI warning removal - "variable was set but never used"

  9002 	if (err == KErrNoMemory)

  9003 		return EPass;

  9004 	else

  9005 		{

  9006 		ERR_PRINTF2(_L(">> CTest_MMF_ACOD_U_0178::DoTestStepL Leave occurred in NewL, error code %d"), err);

  9007 		return EFail;

  9008 		}

  9009 	}

  9010 //------------------------------------------------------------------

  9012 /** @xxxx

  9013  * Constructor

  9014  */

  9015 CTest_MMF_ACOD_U_0179::CTest_MMF_ACOD_U_0179()

  9016 	{

  9017 	// store the name of this test case

  9018 	// this is the name that is used by the script file

  9019 	// Each test step initialises it's own name

  9020 	iTestStepName = _L("MM-MMF-ACOD-U-0179-HP");

  9022 	for (TUint i=0; i<5; i++)

  9023 		{

  9024 		iExpectedSrcBytesProcessed[i] = 0;

  9025 		iExpectedDstBytesAdded[i] = 0;

  9026 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  9027 		}

  9028 	}

  9030 /** @xxxx

  9031  * ALAW To PCM16 Pass in zero sized source buffer

  9032  * @test Req. under test REQ172.6.4, REQ172.6.5

  9033  */

  9034 TVerdict CTest_MMF_ACOD_U_0179::DoTestStepL()

  9035 	{

  9036 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  9037 	TBool testOK = EFalse;

  9038 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KAlawToPCM16OptimumDst));

  9040 	if (err)

  9041 		{

  9042 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9043 		return EFail;

  9044 		}

  9045 	else if (!testOK)

  9046 		{

  9047 		INFO_PRINTF1(_L("Test failed"));

  9048 		return EFail;

  9049 		}

  9050 	else

  9051 		return EPass;

  9052 	}

  9054 //------------------------------------------------------------------

  9056 /** @xxxx

  9057  * Constructor

  9058  */

  9059 CTest_MMF_ACOD_U_0180::CTest_MMF_ACOD_U_0180()

  9060 	{

  9061 	// store the name of this test case

  9062 	// this is the name that is used by the script file

  9063 	// Each test step initialises it's own name

  9064 	iTestStepName = _L("MM-MMF-ACOD-U-0180-HP");

  9066 	iExpectedLeaveErrorCode = KErrArgument;

  9067 	}

  9069 /** @xxxx

  9070  * ALAW To PCM16 Pass in zero sized destination buffer

  9071  * @test Req. under test REQ172.6.4, REQ172.6.5

  9072  */

  9073 TVerdict CTest_MMF_ACOD_U_0180::DoTestStepL()

  9074 	{

  9075 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  9076 	TBool testOK = EFalse;

  9077 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KAlawToPCM16OptimumSrc, 0));

  9079 	if (err)

  9080 		{

  9081 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9082 		return EFail;

  9083 		}

  9084 	else if (!testOK)

  9085 		{

  9086 		INFO_PRINTF1(_L("Test failed"));

  9087 		return EFail;

  9088 		}

  9089 	else

  9090 		return EPass;

  9091 	}

  9093 //------------------------------------------------------------------

  9095 /** @xxxx

  9096  * Constructor

  9097  */

  9098 CTest_MMF_ACOD_U_0181::CTest_MMF_ACOD_U_0181()

  9099 	{

  9100 	// store the name of this test case

  9101 	// this is the name that is used by the script file

  9102 	// Each test step initialises it's own name

  9103 	iTestStepName = _L("MM-MMF-ACOD-U-0181-HP");

  9104 	}

  9106 /** @xxxx

  9107  * ALAW To PCM16 Test out of memory

  9108  * @test Req. under test REQ172.11

  9109  */

  9110 TVerdict CTest_MMF_ACOD_U_0181::DoTestStepL()

  9111 	{

  9112 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  9113 	TBool testOK = EFalse;

  9115 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

  9116 	if (err==KErrNone && testOK)

  9117 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

  9119 	if (err)

  9120 		{

  9121 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9122 		return EFail;

  9123 		}

  9124 	else if (!testOK)

  9125 		{

  9126 		INFO_PRINTF1(_L("Test failed"));

  9127 		return EFail;

  9128 		}

  9129 	else

  9130 		return EPass;

  9131 	}

  9133 //------------------------------------------------------------------

  9136 /** @xxxx

  9137  * Constructor

  9138  */

  9139 CTest_MMF_ACOD_U_0182::CTest_MMF_ACOD_U_0182()

  9140 	{

  9141 	// store the name of this test case

  9142 	// this is the name that is used by the script file

  9143 	// Each test step initialises it's own name

  9144 	iTestStepName = _L("MM-MMF-ACOD-U-0182-HP");

  9145 	}

  9147 /** @xxxx

  9148  * ALAW To PCM16 Test for memory leaks

  9149  * @test Req. under test REQ172.11

  9150  */

  9151 TVerdict CTest_MMF_ACOD_U_0182::DoTestStepL()

  9152 	{

  9153 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  9154 	TBool testOK = EFalse;

  9155 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

  9157 	if (err)

  9158 		{

  9159 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9160 		return EFail;

  9161 		}

  9162 	else if (!testOK)

  9163 		{

  9164 		INFO_PRINTF1(_L("Test failed"));

  9165 		return EFail;

  9166 		}

  9167 	else

  9168 		return EPass;

  9169 	}

  9171 //------------------------------------------------------------------

  9174 /** @xxxx

  9175  * Constructor

  9176  */

  9177 CTest_MMF_ACOD_U_0183::CTest_MMF_ACOD_U_0183()

  9178 	{

  9179 	// store the name of this test case

  9180 	// this is the name that is used by the script file

  9181 	// Each test step initialises it's own name

  9182 	iTestStepName = _L("MM-MMF-ACOD-U-0183-HP");

  9183 	}

  9185 /** @xxxx

  9186  * ALAW To PCM16 Test for memory scribbles

  9187  * @test Req. under test REQ172.11

  9188  */

  9189 TVerdict CTest_MMF_ACOD_U_0183::DoTestStepL()

  9190 	{

  9191 	const TUid codecUid = {KMmfUidCodecAlawToPCM16};

  9192 	TBool testOK = EFalse;

  9193 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

  9195 	if (err)

  9196 		{

  9197 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9198 		return EFail;

  9199 		}

  9200 	else if (!testOK)

  9201 		{

  9202 		INFO_PRINTF1(_L("Test failed"));

  9203 		return EFail;

  9204 		}

  9205 	else

  9206 		return EPass;

  9207 	}

  9209 //------------------------------------------------------------------

  9211 /** @xxxx

  9212  * Constructor

  9213  */

  9214 CTest_MMF_ACOD_U_0184::CTest_MMF_ACOD_U_0184()

  9215 	{

  9216 	// store the name of this test case

  9217 	// this is the name that is used by the script file

  9218 	// Each test step initialises it's own name

  9219 	iTestStepName = _L("MM-MMF-ACOD-U-0184-HP");

  9221 	for (TUint i=0; i<5; i++)

  9222 		{

  9223 		iExpectedSrcBytesProcessed[i] = 0;

  9224 		iExpectedDstBytesAdded[i] = 0;

  9225 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  9226 		}

  9227 	}

  9229 /** @xxxx

  9230  * PCM16 to ALAW Pass in zero sized source buffer

  9231  * @test Req. under test REQ172.6.4, REQ172.6.5

  9232  */

  9233 TVerdict CTest_MMF_ACOD_U_0184::DoTestStepL()

  9234 	{

  9235 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  9236 	TBool testOK = EFalse;

  9237 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToAlawOptimumDst));

  9239 	if (err)

  9240 		{

  9241 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9242 		return EFail;

  9243 		}

  9244 	else if (!testOK)

  9245 		{

  9246 		INFO_PRINTF1(_L("Test failed"));

  9247 		return EFail;

  9248 		}

  9249 	else

  9250 		return EPass;

  9251 	}

  9253 //------------------------------------------------------------------

  9255 /** @xxxx

  9256  * Constructor

  9257  */

  9258 CTest_MMF_ACOD_U_0185::CTest_MMF_ACOD_U_0185()

  9259 	{

  9260 	// store the name of this test case

  9261 	// this is the name that is used by the script file

  9262 	// Each test step initialises it's own name

  9263 	iTestStepName = _L("MM-MMF-ACOD-U-0185-HP");

  9265 	iExpectedLeaveErrorCode = KErrArgument;

  9266 	}

  9268 /** @xxxx

  9269  * PCM16 to ALAW Pass in zero sized destination buffer

  9270  * @test Req. under test REQ172.6.4, REQ172.6.5

  9271  */

  9272 TVerdict CTest_MMF_ACOD_U_0185::DoTestStepL()

  9273 	{

  9274 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  9275 	TBool testOK = EFalse;

  9276 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToAlawOptimumSrc, 0));

  9278 	if (err)

  9279 		{

  9280 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9281 		return EFail;

  9282 		}

  9283 	else if (!testOK)

  9284 		{

  9285 		INFO_PRINTF1(_L("Test failed"));

  9286 		return EFail;

  9287 		}

  9288 	else

  9289 		return EPass;

  9290 	}

  9292 //------------------------------------------------------------------

  9294 /** @xxxx

  9295  * Constructor

  9296  */

  9297 CTest_MMF_ACOD_U_0186::CTest_MMF_ACOD_U_0186()

  9298 	{

  9299 	// store the name of this test case

  9300 	// this is the name that is used by the script file

  9301 	// Each test step initialises it's own name

  9302 	iTestStepName = _L("MM-MMF-ACOD-U-0186-HP");

  9303 	}

  9305 /** @xxxx

  9306  * PCM16 to ALAW Test out of memory

  9307  * @test Req. under test REQ172.11

  9308  */

  9309 TVerdict CTest_MMF_ACOD_U_0186::DoTestStepL()

  9310 	{

  9311 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  9312 	TBool testOK = EFalse;

  9314 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

  9315 	if (err==KErrNone && testOK)

  9316 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

  9318 	if (err)

  9319 		{

  9320 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9321 		return EFail;

  9322 		}

  9323 	else if (!testOK)

  9324 		{

  9325 		INFO_PRINTF1(_L("Test failed"));

  9326 		return EFail;

  9327 		}

  9328 	else

  9329 		return EPass;

  9330 	}

  9332 //------------------------------------------------------------------

  9335 /** @xxxx

  9336  * Constructor

  9337  */

  9338 CTest_MMF_ACOD_U_0187::CTest_MMF_ACOD_U_0187()

  9339 	{

  9340 	// store the name of this test case

  9341 	// this is the name that is used by the script file

  9342 	// Each test step initialises it's own name

  9343 	iTestStepName = _L("MM-MMF-ACOD-U-0187-HP");

  9344 	}

  9346 /** @xxxx

  9347  * PCM16 to ALAW Test for memory leaks

  9348  * @test Req. under test REQ172.11

  9349  */

  9350 TVerdict CTest_MMF_ACOD_U_0187::DoTestStepL()

  9351 	{

  9352 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  9353 	TBool testOK = EFalse;

  9354 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

  9356 	if (err)

  9357 		{

  9358 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9359 		return EFail;

  9360 		}

  9361 	else if (!testOK)

  9362 		{

  9363 		INFO_PRINTF1(_L("Test failed"));

  9364 		return EFail;

  9365 		}

  9366 	else

  9367 		return EPass;

  9368 	}

  9370 //------------------------------------------------------------------

  9373 /** @xxxx

  9374  * Constructor

  9375  */

  9376 CTest_MMF_ACOD_U_0188::CTest_MMF_ACOD_U_0188()

  9377 	{

  9378 	// store the name of this test case

  9379 	// this is the name that is used by the script file

  9380 	// Each test step initialises it's own name

  9381 	iTestStepName = _L("MM-MMF-ACOD-U-0188-HP");

  9382 	}

  9384 /** @xxxx

  9385  * PCM16 to ALAW Test for memory scribbles

  9386  * @test Req. under test REQ172.11

  9387  */

  9388 TVerdict CTest_MMF_ACOD_U_0188::DoTestStepL()

  9389 	{

  9390 	const TUid codecUid = {KMmfUidCodecPCM16ToAlaw};

  9391 	TBool testOK = EFalse;

  9392 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

  9394 	if (err)

  9395 		{

  9396 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9397 		return EFail;

  9398 		}

  9399 	else if (!testOK)

  9400 		{

  9401 		INFO_PRINTF1(_L("Test failed"));

  9402 		return EFail;

  9403 		}

  9404 	else

  9405 		return EPass;

  9406 	}

  9408 //------------------------------------------------------------------

  9410 /** @xxxx

  9411  * Constructor

  9412  */

  9413 CTest_MMF_ACOD_U_0189::CTest_MMF_ACOD_U_0189()

  9414 	{

  9415 	// store the name of this test case

  9416 	// this is the name that is used by the script file

  9417 	// Each test step initialises it's own name

  9418 	iTestStepName = _L("MM-MMF-ACOD-U-0189-HP");

  9420 	for (TUint i=0; i<5; i++)

  9421 		{

  9422 		iExpectedSrcBytesProcessed[i] = 0;

  9423 		iExpectedDstBytesAdded[i] = 0;

  9424 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  9425 		}

  9426 	}

  9428 /** @xxxx

  9429  * PCM8 To PCM16 Pass in zero sized source buffer

  9430  * @test Req. under test REQ172.6.4, REQ172.6.5

  9431  */

  9432 TVerdict CTest_MMF_ACOD_U_0189::DoTestStepL()

  9433 	{

  9434 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  9435 	TBool testOK = EFalse;

  9436 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM8ToPCM16OptimumDst));

  9438 	if (err)

  9439 		{

  9440 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9441 		return EFail;

  9442 		}

  9443 	else if (!testOK)

  9444 		{

  9445 		INFO_PRINTF1(_L("Test failed"));

  9446 		return EFail;

  9447 		}

  9448 	else

  9449 		return EPass;

  9450 	}

  9452 //------------------------------------------------------------------

  9454 /** @xxxx

  9455  * Constructor

  9456  */

  9457 CTest_MMF_ACOD_U_0190::CTest_MMF_ACOD_U_0190()

  9458 	{

  9459 	// store the name of this test case

  9460 	// this is the name that is used by the script file

  9461 	// Each test step initialises it's own name

  9462 	iTestStepName = _L("MM-MMF-ACOD-U-0190-HP");

  9464 	iExpectedLeaveErrorCode = KErrArgument;

  9465 	}

  9467 /** @xxxx

  9468  * PCM8 To PCM16 Pass in zero sized destination buffer

  9469  * @test Req. under test REQ172.6.4, REQ172.6.5

  9470  */

  9471 TVerdict CTest_MMF_ACOD_U_0190::DoTestStepL()

  9472 	{

  9473 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  9474 	TBool testOK = EFalse;

  9475 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM8ToPCM16OptimumSrc, 0));

  9477 	if (err)

  9478 		{

  9479 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9480 		return EFail;

  9481 		}

  9482 	else if (!testOK)

  9483 		{

  9484 		INFO_PRINTF1(_L("Test failed"));

  9485 		return EFail;

  9486 		}

  9487 	else

  9488 		return EPass;

  9489 	}

  9491 //------------------------------------------------------------------

  9493 /** @xxxx

  9494  * Constructor

  9495  */

  9496 CTest_MMF_ACOD_U_0191::CTest_MMF_ACOD_U_0191()

  9497 	{

  9498 	// store the name of this test case

  9499 	// this is the name that is used by the script file

  9500 	// Each test step initialises it's own name

  9501 	iTestStepName = _L("MM-MMF-ACOD-U-0191-HP");

  9502 	}

  9504 /** @xxxx

  9505  * PCM8 To PCM16 Test out of memory

  9506  * @test Req. under test REQ172.11

  9507  */

  9508 TVerdict CTest_MMF_ACOD_U_0191::DoTestStepL()

  9509 	{

  9510 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  9511 	TBool testOK = EFalse;

  9513 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

  9514 	if (err==KErrNone && testOK)

  9515 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

  9517 	if (err)

  9518 		{

  9519 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9520 		return EFail;

  9521 		}

  9522 	else if (!testOK)

  9523 		{

  9524 		INFO_PRINTF1(_L("Test failed"));

  9525 		return EFail;

  9526 		}

  9527 	else

  9528 		return EPass;

  9529 	}

  9531 //------------------------------------------------------------------

  9534 /** @xxxx

  9535  * Constructor

  9536  */

  9537 CTest_MMF_ACOD_U_0192::CTest_MMF_ACOD_U_0192()

  9538 	{

  9539 	// store the name of this test case

  9540 	// this is the name that is used by the script file

  9541 	// Each test step initialises it's own name

  9542 	iTestStepName = _L("MM-MMF-ACOD-U-0192-HP");

  9543 	}

  9545 /** @xxxx

  9546  * PCM8 To PCM16 Test for memory leaks

  9547  * @test Req. under test REQ172.11

  9548  */

  9549 TVerdict CTest_MMF_ACOD_U_0192::DoTestStepL()

  9550 	{

  9551 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  9552 	TBool testOK = EFalse;

  9553 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

  9555 	if (err)

  9556 		{

  9557 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9558 		return EFail;

  9559 		}

  9560 	else if (!testOK)

  9561 		{

  9562 		INFO_PRINTF1(_L("Test failed"));

  9563 		return EFail;

  9564 		}

  9565 	else

  9566 		return EPass;

  9567 	}

  9569 //------------------------------------------------------------------

  9572 /** @xxxx

  9573  * Constructor

  9574  */

  9575 CTest_MMF_ACOD_U_0193::CTest_MMF_ACOD_U_0193()

  9576 	{

  9577 	// store the name of this test case

  9578 	// this is the name that is used by the script file

  9579 	// Each test step initialises it's own name

  9580 	iTestStepName = _L("MM-MMF-ACOD-U-0193-HP");

  9581 	}

  9583 /** @xxxx

  9584  * PCM8 To PCM16 Test for memory scribbles

  9585  * @test Req. under test REQ172.11

  9586  */

  9587 TVerdict CTest_MMF_ACOD_U_0193::DoTestStepL()

  9588 	{

  9589 	const TUid codecUid = {KMmfUidCodecPCM8ToPCM16};

  9590 	TBool testOK = EFalse;

  9591 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

  9593 	if (err)

  9594 		{

  9595 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9596 		return EFail;

  9597 		}

  9598 	else if (!testOK)

  9599 		{

  9600 		INFO_PRINTF1(_L("Test failed"));

  9601 		return EFail;

  9602 		}

  9603 	else

  9604 		return EPass;

  9605 	}

  9607 //------------------------------------------------------------------

  9609 /** @xxxx

  9610  * Constructor

  9611  */

  9612 CTest_MMF_ACOD_U_0194::CTest_MMF_ACOD_U_0194()

  9613 	{

  9614 	// store the name of this test case

  9615 	// this is the name that is used by the script file

  9616 	// Each test step initialises it's own name

  9617 	iTestStepName = _L("MM-MMF-ACOD-U-0194-HP");

  9619 	for (TUint i=0; i<5; i++)

  9620 		{

  9621 		iExpectedSrcBytesProcessed[i] = 0;

  9622 		iExpectedDstBytesAdded[i] = 0;

  9623 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  9624 		}

  9625 	}

  9627 /** @xxxx

  9628  * PCM16 to PCM8 Pass in zero sized source buffer

  9629  * @test Req. under test REQ172.6.4, REQ172.6.5

  9630  */

  9631 TVerdict CTest_MMF_ACOD_U_0194::DoTestStepL()

  9632 	{

  9633 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  9634 	TBool testOK = EFalse;

  9635 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToPCM8OptimumDst));

  9637 	if (err)

  9638 		{

  9639 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9640 		return EFail;

  9641 		}

  9642 	else if (!testOK)

  9643 		{

  9644 		INFO_PRINTF1(_L("Test failed"));

  9645 		return EFail;

  9646 		}

  9647 	else

  9648 		return EPass;

  9649 	}

  9651 //------------------------------------------------------------------

  9653 /** @xxxx

  9654  * Constructor

  9655  */

  9656 CTest_MMF_ACOD_U_0195::CTest_MMF_ACOD_U_0195()

  9657 	{

  9658 	// store the name of this test case

  9659 	// this is the name that is used by the script file

  9660 	// Each test step initialises it's own name

  9661 	iTestStepName = _L("MM-MMF-ACOD-U-0195-HP");

  9663 	iExpectedLeaveErrorCode = KErrArgument;

  9664 	}

  9666 /** @xxxx

  9667  * PCM16 to PCM8 Pass in zero sized destination buffer

  9668  * @test Req. under test REQ172.6.4, REQ172.6.5

  9669  */

  9670 TVerdict CTest_MMF_ACOD_U_0195::DoTestStepL()

  9671 	{

  9672 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  9673 	TBool testOK = EFalse;

  9674 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCM8OptimumSrc, 0));

  9676 	if (err)

  9677 		{

  9678 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9679 		return EFail;

  9680 		}

  9681 	else if (!testOK)

  9682 		{

  9683 		INFO_PRINTF1(_L("Test failed"));

  9684 		return EFail;

  9685 		}

  9686 	else

  9687 		return EPass;

  9688 	}

  9690 //------------------------------------------------------------------

  9692 /** @xxxx

  9693  * Constructor

  9694  */

  9695 CTest_MMF_ACOD_U_0196::CTest_MMF_ACOD_U_0196()

  9696 	{

  9697 	// store the name of this test case

  9698 	// this is the name that is used by the script file

  9699 	// Each test step initialises it's own name

  9700 	iTestStepName = _L("MM-MMF-ACOD-U-0196-HP");

  9701 	}

  9703 /** @xxxx

  9704  * PCM16 to PCM8 Test out of memory

  9705  * @test Req. under test REQ172.11

  9706  */

  9707 TVerdict CTest_MMF_ACOD_U_0196::DoTestStepL()

  9708 	{

  9709 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  9710 	TBool testOK = EFalse;

  9712 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

  9713 	if (err==KErrNone && testOK)

  9714 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

  9716 	if (err)

  9717 		{

  9718 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9719 		return EFail;

  9720 		}

  9721 	else if (!testOK)

  9722 		{

  9723 		INFO_PRINTF1(_L("Test failed"));

  9724 		return EFail;

  9725 		}

  9726 	else

  9727 		return EPass;

  9728 	}

  9730 //------------------------------------------------------------------

  9733 /** @xxxx

  9734  * Constructor

  9735  */

  9736 CTest_MMF_ACOD_U_0197::CTest_MMF_ACOD_U_0197()

  9737 	{

  9738 	// store the name of this test case

  9739 	// this is the name that is used by the script file

  9740 	// Each test step initialises it's own name

  9741 	iTestStepName = _L("MM-MMF-ACOD-U-0197-HP");

  9742 	}

  9744 /** @xxxx

  9745  * PCM16 to PCM8 Test for memory leaks

  9746  * @test Req. under test REQ172.11

  9747  */

  9748 TVerdict CTest_MMF_ACOD_U_0197::DoTestStepL()

  9749 	{

  9750 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  9751 	TBool testOK = EFalse;

  9752 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

  9754 	if (err)

  9755 		{

  9756 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9757 		return EFail;

  9758 		}

  9759 	else if (!testOK)

  9760 		{

  9761 		INFO_PRINTF1(_L("Test failed"));

  9762 		return EFail;

  9763 		}

  9764 	else

  9765 		return EPass;

  9766 	}

  9768 //------------------------------------------------------------------

  9771 /** @xxxx

  9772  * Constructor

  9773  */

  9774 CTest_MMF_ACOD_U_0198::CTest_MMF_ACOD_U_0198()

  9775 	{

  9776 	// store the name of this test case

  9777 	// this is the name that is used by the script file

  9778 	// Each test step initialises it's own name

  9779 	iTestStepName = _L("MM-MMF-ACOD-U-0198-HP");

  9780 	}

  9782 /** @xxxx

  9783  * PCM16 to PCM8 Test for memory scribbles

  9784  * @test Req. under test REQ172.11

  9785  */

  9786 TVerdict CTest_MMF_ACOD_U_0198::DoTestStepL()

  9787 	{

  9788 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMS8};

  9789 	TBool testOK = EFalse;

  9790 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

  9792 	if (err)

  9793 		{

  9794 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9795 		return EFail;

  9796 		}

  9797 	else if (!testOK)

  9798 		{

  9799 		INFO_PRINTF1(_L("Test failed"));

  9800 		return EFail;

  9801 		}

  9802 	else

  9803 		return EPass;

  9804 	}

  9806 //------------------------------------------------------------------

  9808 /** @xxxx

  9809  * Constructor

  9810  */

  9811 CTest_MMF_ACOD_U_0199::CTest_MMF_ACOD_U_0199()

  9812 	{

  9813 	// store the name of this test case

  9814 	// this is the name that is used by the script file

  9815 	// Each test step initialises it's own name

  9816 	iTestStepName = _L("MM-MMF-ACOD-U-0199-HP");

  9818 	for (TUint i=0; i<5; i++)

  9819 		{

  9820 		iExpectedSrcBytesProcessed[i] = 0;

  9821 		iExpectedDstBytesAdded[i] = 0;

  9822 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

  9823 		}

  9824 	}

  9826 /** @xxxx

  9827  * Swap Endian Pass in zero sized source buffer

  9828  * @test Req. under test REQ172.6.4, REQ172.6.5

  9829  */

  9830 TVerdict CTest_MMF_ACOD_U_0199::DoTestStepL()

  9831 	{

  9832 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  9833 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  9834 	TBool testOK = EFalse;

  9835 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToPCM16BOptimumDst));

  9837 	if (err)

  9838 		{

  9839 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9840 		return EFail;

  9841 		}

  9842 	else if (!testOK)

  9843 		{

  9844 		INFO_PRINTF1(_L("Test failed"));

  9845 		return EFail;

  9846 		}

  9847 	else

  9848 		return EPass;

  9849 	}

  9851 //------------------------------------------------------------------

  9853 /** @xxxx

  9854  * Constructor

  9855  */

  9856 CTest_MMF_ACOD_U_0200::CTest_MMF_ACOD_U_0200()

  9857 	{

  9858 	// store the name of this test case

  9859 	// this is the name that is used by the script file

  9860 	// Each test step initialises it's own name

  9861 	iTestStepName = _L("MM-MMF-ACOD-U-0200-HP");

  9863 	iExpectedLeaveErrorCode = KErrArgument;

  9864 	}

  9866 /** @xxxx

  9867  * Swap Endian Pass in zero sized destination buffer

  9868  * @test Req. under test REQ172.6.4, REQ172.6.5

  9869  */

  9870 TVerdict CTest_MMF_ACOD_U_0200::DoTestStepL()

  9871 	{

  9872 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  9873 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  9874 	TBool testOK = EFalse;

  9875 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCM16BOptimumSrc, 0));

  9877 	if (err)

  9878 		{

  9879 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9880 		return EFail;

  9881 		}

  9882 	else if (!testOK)

  9883 		{

  9884 		INFO_PRINTF1(_L("Test failed"));

  9885 		return EFail;

  9886 		}

  9887 	else

  9888 		return EPass;

  9889 	}

  9891 //------------------------------------------------------------------

  9893 /** @xxxx

  9894  * Constructor

  9895  */

  9896 CTest_MMF_ACOD_U_0201::CTest_MMF_ACOD_U_0201()

  9897 	{

  9898 	// store the name of this test case

  9899 	// this is the name that is used by the script file

  9900 	// Each test step initialises it's own name

  9901 	iTestStepName = _L("MM-MMF-ACOD-U-0201-HP");

  9902 	}

  9904 /** @xxxx

  9905  * Swap Endian Test out of memory

  9906  * @test Req. under test REQ172.11

  9907  */

  9908 TVerdict CTest_MMF_ACOD_U_0201::DoTestStepL()

  9909 	{

  9910 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  9911 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  9912 	TBool testOK = EFalse;

  9914 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

  9915 	if (err==KErrNone && testOK)

  9916 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

  9918 	if (err)

  9919 		{

  9920 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9921 		return EFail;

  9922 		}

  9923 	else if (!testOK)

  9924 		{

  9925 		INFO_PRINTF1(_L("Test failed"));

  9926 		return EFail;

  9927 		}

  9928 	else

  9929 		return EPass;

  9930 	}

  9932 //------------------------------------------------------------------

  9935 /** @xxxx

  9936  * Constructor

  9937  */

  9938 CTest_MMF_ACOD_U_0202::CTest_MMF_ACOD_U_0202()

  9939 	{

  9940 	// store the name of this test case

  9941 	// this is the name that is used by the script file

  9942 	// Each test step initialises it's own name

  9943 	iTestStepName = _L("MM-MMF-ACOD-U-0202-HP");

  9944 	}

  9946 /** @xxxx

  9947  * Swap Endian Test for memory leaks

  9948  * @test Req. under test REQ172.11

  9949  */

  9950 TVerdict CTest_MMF_ACOD_U_0202::DoTestStepL()

  9951 	{

  9952 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  9953 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  9954 	TBool testOK = EFalse;

  9955 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

  9957 	if (err)

  9958 		{

  9959 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9960 		return EFail;

  9961 		}

  9962 	else if (!testOK)

  9963 		{

  9964 		INFO_PRINTF1(_L("Test failed"));

  9965 		return EFail;

  9966 		}

  9967 	else

  9968 		return EPass;

  9969 	}

  9971 //------------------------------------------------------------------

  9974 /** @xxxx

  9975  * Constructor

  9976  */

  9977 CTest_MMF_ACOD_U_0203::CTest_MMF_ACOD_U_0203()

  9978 	{

  9979 	// store the name of this test case

  9980 	// this is the name that is used by the script file

  9981 	// Each test step initialises it's own name

  9982 	iTestStepName = _L("MM-MMF-ACOD-U-0203-HP");

  9983 	}

  9985 /** @xxxx

  9986  * Swap Endian Test for memory scribbles

  9987  * @test Req. under test REQ172.11

  9988  */

  9989 TVerdict CTest_MMF_ACOD_U_0203::DoTestStepL()

  9990 	{

  9991 	//const TUid codecUid = {KMMFUidCodecPCM16SwapEndian};

  9992 	const TUid codecUid = {KMMFUidCodecPCM16toPCM16B};

  9993 	TBool testOK = EFalse;

  9994 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

  9996 	if (err)

  9997 		{

  9998 		INFO_PRINTF2(_L("Test left with status %d"), err);

  9999 		return EFail;

 10000 		}

 10001 	else if (!testOK)

 10002 		{

 10003 		INFO_PRINTF1(_L("Test failed"));

 10004 		return EFail;

 10005 		}

 10006 	else

 10007 		return EPass;

 10008 	}

 10010 //------------------------------------------------------------------

 10012 /** @xxxx

 10013  * Constructor

 10014  */

 10015 CTest_MMF_ACOD_U_0204::CTest_MMF_ACOD_U_0204()

 10016 	{

 10017 	// store the name of this test case

 10018 	// this is the name that is used by the script file

 10019 	// Each test step initialises it's own name

 10020 	iTestStepName = _L("MM-MMF-ACOD-U-0204-HP");

 10022 	for (TUint i=0; i<5; i++)

 10023 		{

 10024 		iExpectedSrcBytesProcessed[i] = 0;

 10025 		iExpectedDstBytesAdded[i] = 0;

 10026 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 10027 		}

 10028 	}

 10030 /** @xxxx

 10031  * PCM16 to PCMU16BE Pass in zero sized source buffer

 10032  * @test Req. under test REQ172.6.4, REQ172.6.5

 10033  */

 10034 TVerdict CTest_MMF_ACOD_U_0204::DoTestStepL()

 10035 	{

 10036 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

 10037 	TBool testOK = EFalse;

 10038 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToPCMU16BOptimumDst));

 10040 	if (err)

 10041 		{

 10042 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10043 		return EFail;

 10044 		}

 10045 	else if (!testOK)

 10046 		{

 10047 		INFO_PRINTF1(_L("Test failed"));

 10048 		return EFail;

 10049 		}

 10050 	else

 10051 		return EPass;

 10052 	}

 10054 //------------------------------------------------------------------

 10056 /** @xxxx

 10057  * Constructor

 10058  */

 10059 CTest_MMF_ACOD_U_0205::CTest_MMF_ACOD_U_0205()

 10060 	{

 10061 	// store the name of this test case

 10062 	// this is the name that is used by the script file

 10063 	// Each test step initialises it's own name

 10064 	iTestStepName = _L("MM-MMF-ACOD-U-0205-HP");

 10066 	iExpectedLeaveErrorCode = KErrArgument;

 10067 	}

 10069 /** @xxxx

 10070  * PCM16 to PCMU16BE Pass in zero sized destination buffer

 10071  * @test Req. under test REQ172.6.4, REQ172.6.5

 10072  */

 10073 TVerdict CTest_MMF_ACOD_U_0205::DoTestStepL()

 10074 	{

 10075 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

 10076 	TBool testOK = EFalse;

 10077 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCMU16BOptimumSrc, 0));

 10079 	if (err)

 10080 		{

 10081 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10082 		return EFail;

 10083 		}

 10084 	else if (!testOK)

 10085 		{

 10086 		INFO_PRINTF1(_L("Test failed"));

 10087 		return EFail;

 10088 		}

 10089 	else

 10090 		return EPass;

 10091 	}

 10093 //------------------------------------------------------------------

 10095 /** @xxxx

 10096  * Constructor

 10097  */

 10098 CTest_MMF_ACOD_U_0206::CTest_MMF_ACOD_U_0206()

 10099 	{

 10100 	// store the name of this test case

 10101 	// this is the name that is used by the script file

 10102 	// Each test step initialises it's own name

 10103 	iTestStepName = _L("MM-MMF-ACOD-U-0206-HP");

 10104 	}

 10106 /** @xxxx

 10107  * PCM16 to PCMU16BE Test out of memory

 10108  * @test Req. under test REQ172.11

 10109  */

 10110 TVerdict CTest_MMF_ACOD_U_0206::DoTestStepL()

 10111 	{

 10112 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

 10113 	TBool testOK = EFalse;

 10115 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 10116 	if (err==KErrNone && testOK)

 10117 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 10119 	if (err)

 10120 		{

 10121 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10122 		return EFail;

 10123 		}

 10124 	else if (!testOK)

 10125 		{

 10126 		INFO_PRINTF1(_L("Test failed"));

 10127 		return EFail;

 10128 		}

 10129 	else

 10130 		return EPass;

 10131 	}

 10133 //------------------------------------------------------------------

 10136 /** @xxxx

 10137  * Constructor

 10138  */

 10139 CTest_MMF_ACOD_U_0207::CTest_MMF_ACOD_U_0207()

 10140 	{

 10141 	// store the name of this test case

 10142 	// this is the name that is used by the script file

 10143 	// Each test step initialises it's own name

 10144 	iTestStepName = _L("MM-MMF-ACOD-U-0207-HP");

 10145 	}

 10147 /** @xxxx

 10148  * PCM16 to PCMU16BE Test for memory leaks

 10149  * @test Req. under test REQ172.11

 10150  */

 10151 TVerdict CTest_MMF_ACOD_U_0207::DoTestStepL()

 10152 	{

 10153 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

 10154 	TBool testOK = EFalse;

 10155 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 10157 	if (err)

 10158 		{

 10159 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10160 		return EFail;

 10161 		}

 10162 	else if (!testOK)

 10163 		{

 10164 		INFO_PRINTF1(_L("Test failed"));

 10165 		return EFail;

 10166 		}

 10167 	else

 10168 		return EPass;

 10169 	}

 10171 //------------------------------------------------------------------

 10174 /** @xxxx

 10175  * Constructor

 10176  */

 10177 CTest_MMF_ACOD_U_0208::CTest_MMF_ACOD_U_0208()

 10178 	{

 10179 	// store the name of this test case

 10180 	// this is the name that is used by the script file

 10181 	// Each test step initialises it's own name

 10182 	iTestStepName = _L("MM-MMF-ACOD-U-0208-HP");

 10183 	}

 10185 /** @xxxx

 10186  * PCM16 to PCMU16BE Test for memory scribbles

 10187  * @test Req. under test REQ172.11

 10188  */

 10189 TVerdict CTest_MMF_ACOD_U_0208::DoTestStepL()

 10190 	{

 10191 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16BE};

 10192 	TBool testOK = EFalse;

 10193 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 10195 	if (err)

 10196 		{

 10197 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10198 		return EFail;

 10199 		}

 10200 	else if (!testOK)

 10201 		{

 10202 		INFO_PRINTF1(_L("Test failed"));

 10203 		return EFail;

 10204 		}

 10205 	else

 10206 		return EPass;

 10207 	}

 10209 //------------------------------------------------------------------

 10211 /** @xxxx

 10212  * Constructor

 10213  */

 10214 CTest_MMF_ACOD_U_0209::CTest_MMF_ACOD_U_0209()

 10215 	{

 10216 	// store the name of this test case

 10217 	// this is the name that is used by the script file

 10218 	// Each test step initialises it's own name

 10219 	iTestStepName = _L("MM-MMF-ACOD-U-0209-HP");

 10221 	for (TUint i=0; i<5; i++)

 10222 		{

 10223 		iExpectedSrcBytesProcessed[i] = 0;

 10224 		iExpectedDstBytesAdded[i] = 0;

 10225 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 10226 		}

 10227 	}

 10229 /** @xxxx

 10230  * PCM16 to PCMU16 Pass in zero sized source buffer

 10231  * @test Req. under test REQ172.6.4, REQ172.6.5

 10232  */

 10233 TVerdict CTest_MMF_ACOD_U_0209::DoTestStepL()

 10234 	{

 10235 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

 10236 	TBool testOK = EFalse;

 10237 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToPCMU16OptimumDst));

 10239 	if (err)

 10240 		{

 10241 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10242 		return EFail;

 10243 		}

 10244 	else if (!testOK)

 10245 		{

 10246 		INFO_PRINTF1(_L("Test failed"));

 10247 		return EFail;

 10248 		}

 10249 	else

 10250 		return EPass;

 10251 	}

 10253 //------------------------------------------------------------------

 10255 /** @xxxx

 10256  * Constructor

 10257  */

 10258 CTest_MMF_ACOD_U_0210::CTest_MMF_ACOD_U_0210()

 10259 	{

 10260 	// store the name of this test case

 10261 	// this is the name that is used by the script file

 10262 	// Each test step initialises it's own name

 10263 	iTestStepName = _L("MM-MMF-ACOD-U-0210-HP");

 10265 	iExpectedLeaveErrorCode = KErrArgument;

 10266 	}

 10268 /** @xxxx

 10269  * PCM16 to PCMU16 Pass in zero sized destination buffer

 10270  * @test Req. under test REQ172.6.4, REQ172.6.5

 10271  */

 10272 TVerdict CTest_MMF_ACOD_U_0210::DoTestStepL()

 10273 	{

 10274 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

 10275 	TBool testOK = EFalse;

 10276 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCMU16OptimumSrc, 0));

 10278 	if (err)

 10279 		{

 10280 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10281 		return EFail;

 10282 		}

 10283 	else if (!testOK)

 10284 		{

 10285 		INFO_PRINTF1(_L("Test failed"));

 10286 		return EFail;

 10287 		}

 10288 	else

 10289 		return EPass;

 10290 	}

 10292 //------------------------------------------------------------------

 10294 /** @xxxx

 10295  * Constructor

 10296  */

 10297 CTest_MMF_ACOD_U_0211::CTest_MMF_ACOD_U_0211()

 10298 	{

 10299 	// store the name of this test case

 10300 	// this is the name that is used by the script file

 10301 	// Each test step initialises it's own name

 10302 	iTestStepName = _L("MM-MMF-ACOD-U-0211-HP");

 10303 	}

 10305 /** @xxxx

 10306  * PCM16 to PCMU16 Test out of memory

 10307  * @test Req. under test REQ172.11

 10308  */

 10309 TVerdict CTest_MMF_ACOD_U_0211::DoTestStepL()

 10310 	{

 10311 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

 10312 	TBool testOK = EFalse;

 10314 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 10315 	if (err==KErrNone && testOK)

 10316 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 10318 	if (err)

 10319 		{

 10320 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10321 		return EFail;

 10322 		}

 10323 	else if (!testOK)

 10324 		{

 10325 		INFO_PRINTF1(_L("Test failed"));

 10326 		return EFail;

 10327 		}

 10328 	else

 10329 		return EPass;

 10330 	}

 10332 //------------------------------------------------------------------

 10335 /** @xxxx

 10336  * Constructor

 10337  */

 10338 CTest_MMF_ACOD_U_0212::CTest_MMF_ACOD_U_0212()

 10339 	{

 10340 	// store the name of this test case

 10341 	// this is the name that is used by the script file

 10342 	// Each test step initialises it's own name

 10343 	iTestStepName = _L("MM-MMF-ACOD-U-0212-HP");

 10344 	}

 10346 /** @xxxx

 10347  * PCM16 to PCMU16 Test for memory leaks

 10348  * @test Req. under test REQ172.11

 10349  */

 10350 TVerdict CTest_MMF_ACOD_U_0212::DoTestStepL()

 10351 	{

 10352 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

 10353 	TBool testOK = EFalse;

 10354 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 10356 	if (err)

 10357 		{

 10358 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10359 		return EFail;

 10360 		}

 10361 	else if (!testOK)

 10362 		{

 10363 		INFO_PRINTF1(_L("Test failed"));

 10364 		return EFail;

 10365 		}

 10366 	else

 10367 		return EPass;

 10368 	}

 10370 //------------------------------------------------------------------

 10373 /** @xxxx

 10374  * Constructor

 10375  */

 10376 CTest_MMF_ACOD_U_0213::CTest_MMF_ACOD_U_0213()

 10377 	{

 10378 	// store the name of this test case

 10379 	// this is the name that is used by the script file

 10380 	// Each test step initialises it's own name

 10381 	iTestStepName = _L("MM-MMF-ACOD-U-0213-HP");

 10382 	}

 10384 /** @xxxx

 10385  * PCM16 to PCMU16 Test for memory scribbles

 10386  * @test Req. under test REQ172.11

 10387  */

 10388 TVerdict CTest_MMF_ACOD_U_0213::DoTestStepL()

 10389 	{

 10390 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU16};

 10391 	TBool testOK = EFalse;

 10392 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 10394 	if (err)

 10395 		{

 10396 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10397 		return EFail;

 10398 		}

 10399 	else if (!testOK)

 10400 		{

 10401 		INFO_PRINTF1(_L("Test failed"));

 10402 		return EFail;

 10403 		}

 10404 	else

 10405 		return EPass;

 10406 	}

 10408 //------------------------------------------------------------------

 10409 /** @xxxx

 10410  * Constructor

 10411  */

 10412 CTest_MMF_ACOD_U_0214::CTest_MMF_ACOD_U_0214()

 10413 	{

 10414 	// store the name of this test case

 10415 	// this is the name that is used by the script file

 10416 	// Each test step initialises it's own name

 10417 	iTestStepName = _L("MM-MMF-ACOD-U-0214-HP");

 10419 	for (TUint i=0; i<5; i++)

 10420 		{

 10421 		iExpectedSrcBytesProcessed[i] = 0;

 10422 		iExpectedDstBytesAdded[i] = 0;

 10423 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 10424 		}

 10425 	}

 10427 /** @xxxx

 10428  * PCM16 to PCMU8 Pass in zero sized source buffer

 10429  * @test Req. under test REQ172.6.4, REQ172.6.5

 10430  */

 10431 TVerdict CTest_MMF_ACOD_U_0214::DoTestStepL()

 10432 	{

 10433 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

 10434 	TBool testOK = EFalse;

 10435 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToPCMU8OptimumDst));

 10437 	if (err)

 10438 		{

 10439 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10440 		return EFail;

 10441 		}

 10442 	else if (!testOK)

 10443 		{

 10444 		INFO_PRINTF1(_L("Test failed"));

 10445 		return EFail;

 10446 		}

 10447 	else

 10448 		return EPass;

 10449 	}

 10451 //------------------------------------------------------------------

 10453 /** @xxxx

 10454  * Constructor

 10455  */

 10456 CTest_MMF_ACOD_U_0215::CTest_MMF_ACOD_U_0215()

 10457 	{

 10458 	// store the name of this test case

 10459 	// this is the name that is used by the script file

 10460 	// Each test step initialises it's own name

 10461 	iTestStepName = _L("MM-MMF-ACOD-U-0215-HP");

 10463 	iExpectedLeaveErrorCode = KErrArgument;

 10464 	}

 10466 /** @xxxx

 10467  * PCM16 to PCMU8 Pass in zero sized destination buffer

 10468  * @test Req. under test REQ172.6.4, REQ172.6.5

 10469  */

 10470 TVerdict CTest_MMF_ACOD_U_0215::DoTestStepL()

 10471 	{

 10472 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

 10473 	TBool testOK = EFalse;

 10474 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToPCMU8OptimumSrc, 0));

 10476 	if (err)

 10477 		{

 10478 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10479 		return EFail;

 10480 		}

 10481 	else if (!testOK)

 10482 		{

 10483 		INFO_PRINTF1(_L("Test failed"));

 10484 		return EFail;

 10485 		}

 10486 	else

 10487 		return EPass;

 10488 	}

 10490 //------------------------------------------------------------------

 10492 /** @xxxx

 10493  * Constructor

 10494  */

 10495 CTest_MMF_ACOD_U_0216::CTest_MMF_ACOD_U_0216()

 10496 	{

 10497 	// store the name of this test case

 10498 	// this is the name that is used by the script file

 10499 	// Each test step initialises it's own name

 10500 	iTestStepName = _L("MM-MMF-ACOD-U-0216-HP");

 10501 	}

 10503 /** @xxxx

 10504  * PCM16 to PCMU8 Test out of memory

 10505  * @test Req. under test REQ172.11

 10506  */

 10507 TVerdict CTest_MMF_ACOD_U_0216::DoTestStepL()

 10508 	{

 10509 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

 10510 	TBool testOK = EFalse;

 10512 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 10513 	if (err==KErrNone && testOK)

 10514 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 10516 	if (err)

 10517 		{

 10518 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10519 		return EFail;

 10520 		}

 10521 	else if (!testOK)

 10522 		{

 10523 		INFO_PRINTF1(_L("Test failed"));

 10524 		return EFail;

 10525 		}

 10526 	else

 10527 		return EPass;

 10528 	}

 10530 //------------------------------------------------------------------

 10533 /** @xxxx

 10534  * Constructor

 10535  */

 10536 CTest_MMF_ACOD_U_0217::CTest_MMF_ACOD_U_0217()

 10537 	{

 10538 	// store the name of this test case

 10539 	// this is the name that is used by the script file

 10540 	// Each test step initialises it's own name

 10541 	iTestStepName = _L("MM-MMF-ACOD-U-0217-HP");

 10542 	}

 10544 /** @xxxx

 10545  * PCM16 to PCMU8 Test for memory leaks

 10546  * @test Req. under test REQ172.11

 10547  */

 10548 TVerdict CTest_MMF_ACOD_U_0217::DoTestStepL()

 10549 	{

 10550 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

 10551 	TBool testOK = EFalse;

 10552 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 10554 	if (err)

 10555 		{

 10556 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10557 		return EFail;

 10558 		}

 10559 	else if (!testOK)

 10560 		{

 10561 		INFO_PRINTF1(_L("Test failed"));

 10562 		return EFail;

 10563 		}

 10564 	else

 10565 		return EPass;

 10566 	}

 10568 //------------------------------------------------------------------

 10571 /** @xxxx

 10572  * Constructor

 10573  */

 10574 CTest_MMF_ACOD_U_0218::CTest_MMF_ACOD_U_0218()

 10575 	{

 10576 	// store the name of this test case

 10577 	// this is the name that is used by the script file

 10578 	// Each test step initialises it's own name

 10579 	iTestStepName = _L("MM-MMF-ACOD-U-0218-HP");

 10580 	}

 10582 /** @xxxx

 10583  * PCM16 to PCMU8 Test for memory scribbles

 10584  * @test Req. under test REQ172.11

 10585  */

 10586 TVerdict CTest_MMF_ACOD_U_0218::DoTestStepL()

 10587 	{

 10588 	const TUid codecUid = {KMmfUidCodecAudioS16ToPCMU8};

 10589 	TBool testOK = EFalse;

 10590 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 10592 	if (err)

 10593 		{

 10594 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10595 		return EFail;

 10596 		}

 10597 	else if (!testOK)

 10598 		{

 10599 		INFO_PRINTF1(_L("Test failed"));

 10600 		return EFail;

 10601 		}

 10602 	else

 10603 		return EPass;

 10604 	}

 10606 //------------------------------------------------------------------

 10608 /** @xxxx

 10609  * Constructor

 10610  */

 10611 CTest_MMF_ACOD_U_0219::CTest_MMF_ACOD_U_0219()

 10612 	{

 10613 	// store the name of this test case

 10614 	// this is the name that is used by the script file

 10615 	// Each test step initialises it's own name

 10616 	iTestStepName = _L("MM-MMF-ACOD-U-0219-HP");

 10618 	for (TUint i=0; i<5; i++)

 10619 		{

 10620 		iExpectedSrcBytesProcessed[i] = 0;

 10621 		iExpectedDstBytesAdded[i] = 0;

 10622 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 10623 		}

 10624 	}

 10626 /** @xxxx

 10627  * PCMU16BE to PCM16 Pass in zero sized source buffer

 10628  * @test Req. under test REQ172.6.4, REQ172.6.5

 10629  */

 10630 TVerdict CTest_MMF_ACOD_U_0219::DoTestStepL()

 10631 	{

 10632 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

 10633 	TBool testOK = EFalse;

 10634 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCMU16BToPCM16OptimumDst));

 10636 	if (err)

 10637 		{

 10638 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10639 		return EFail;

 10640 		}

 10641 	else if (!testOK)

 10642 		{

 10643 		INFO_PRINTF1(_L("Test failed"));

 10644 		return EFail;

 10645 		}

 10646 	else

 10647 		return EPass;

 10648 	}

 10650 //------------------------------------------------------------------

 10652 /** @xxxx

 10653  * Constructor

 10654  */

 10655 CTest_MMF_ACOD_U_0220::CTest_MMF_ACOD_U_0220()

 10656 	{

 10657 	// store the name of this test case

 10658 	// this is the name that is used by the script file

 10659 	// Each test step initialises it's own name

 10660 	iTestStepName = _L("MM-MMF-ACOD-U-0220-HP");

 10662 	iExpectedLeaveErrorCode = KErrArgument;

 10663 	}

 10665 /** @xxxx

 10666  * PCMU16BE to PCM16 Pass in zero sized destination buffer

 10667  * @test Req. under test REQ172.6.4, REQ172.6.5

 10668  */

 10669 TVerdict CTest_MMF_ACOD_U_0220::DoTestStepL()

 10670 	{

 10671 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

 10672 	TBool testOK = EFalse;

 10673 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCMU16BToPCM16OptimumSrc, 0));

 10675 	if (err)

 10676 		{

 10677 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10678 		return EFail;

 10679 		}

 10680 	else if (!testOK)

 10681 		{

 10682 		INFO_PRINTF1(_L("Test failed"));

 10683 		return EFail;

 10684 		}

 10685 	else

 10686 		return EPass;

 10687 	}

 10689 //------------------------------------------------------------------

 10691 /** @xxxx

 10692  * Constructor

 10693  */

 10694 CTest_MMF_ACOD_U_0221::CTest_MMF_ACOD_U_0221()

 10695 	{

 10696 	// store the name of this test case

 10697 	// this is the name that is used by the script file

 10698 	// Each test step initialises it's own name

 10699 	iTestStepName = _L("MM-MMF-ACOD-U-0221-HP");

 10700 	}

 10702 /** @xxxx

 10703  * PCMU16BE to PCM16 Test out of memory

 10704  * @test Req. under test REQ172.11

 10705  */

 10706 TVerdict CTest_MMF_ACOD_U_0221::DoTestStepL()

 10707 	{

 10708 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

 10709 	TBool testOK = EFalse;

 10711 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 10712 	if (err==KErrNone && testOK)

 10713 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 10715 	if (err)

 10716 		{

 10717 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10718 		return EFail;

 10719 		}

 10720 	else if (!testOK)

 10721 		{

 10722 		INFO_PRINTF1(_L("Test failed"));

 10723 		return EFail;

 10724 		}

 10725 	else

 10726 		return EPass;

 10727 	}

 10729 //------------------------------------------------------------------

 10732 /** @xxxx

 10733  * Constructor

 10734  */

 10735 CTest_MMF_ACOD_U_0222::CTest_MMF_ACOD_U_0222()

 10736 	{

 10737 	// store the name of this test case

 10738 	// this is the name that is used by the script file

 10739 	// Each test step initialises it's own name

 10740 	iTestStepName = _L("MM-MMF-ACOD-U-0222-HP");

 10741 	}

 10743 /** @xxxx

 10744  * PCMU16BE to PCM16 Test for memory leaks

 10745  * @test Req. under test REQ172.11

 10746  */

 10747 TVerdict CTest_MMF_ACOD_U_0222::DoTestStepL()

 10748 	{

 10749 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

 10750 	TBool testOK = EFalse;

 10751 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 10753 	if (err)

 10754 		{

 10755 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10756 		return EFail;

 10757 		}

 10758 	else if (!testOK)

 10759 		{

 10760 		INFO_PRINTF1(_L("Test failed"));

 10761 		return EFail;

 10762 		}

 10763 	else

 10764 		return EPass;

 10765 	}

 10767 //------------------------------------------------------------------

 10770 /** @xxxx

 10771  * Constructor

 10772  */

 10773 CTest_MMF_ACOD_U_0223::CTest_MMF_ACOD_U_0223()

 10774 	{

 10775 	// store the name of this test case

 10776 	// this is the name that is used by the script file

 10777 	// Each test step initialises it's own name

 10778 	iTestStepName = _L("MM-MMF-ACOD-U-0223-HP");

 10779 	}

 10781 /** @xxxx

 10782  * PCMU16BE to PCM16 Test for memory scribbles

 10783  * @test Req. under test REQ172.11

 10784  */

 10785 TVerdict CTest_MMF_ACOD_U_0223::DoTestStepL()

 10786 	{

 10787 	const TUid codecUid = {KMmfUidCodecAudioU16BEToPCMS16};

 10788 	TBool testOK = EFalse;

 10789 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 10791 	if (err)

 10792 		{

 10793 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10794 		return EFail;

 10795 		}

 10796 	else if (!testOK)

 10797 		{

 10798 		INFO_PRINTF1(_L("Test failed"));

 10799 		return EFail;

 10800 		}

 10801 	else

 10802 		return EPass;

 10803 	}

 10805 //------------------------------------------------------------------

 10807 /** @xxxx

 10808  * Constructor

 10809  */

 10810 CTest_MMF_ACOD_U_0224::CTest_MMF_ACOD_U_0224()

 10811 	{

 10812 	// store the name of this test case

 10813 	// this is the name that is used by the script file

 10814 	// Each test step initialises it's own name

 10815 	iTestStepName = _L("MM-MMF-ACOD-U-0224-HP");

 10817 	for (TUint i=0; i<5; i++)

 10818 		{

 10819 		iExpectedSrcBytesProcessed[i] = 0;

 10820 		iExpectedDstBytesAdded[i] = 0;

 10821 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 10822 		}

 10823 	}

 10825 /** @xxxx

 10826  * PCMU16 to PCM16 Pass in zero sized source buffer

 10827  * @test Req. under test REQ172.6.4, REQ172.6.5

 10828  */

 10829 TVerdict CTest_MMF_ACOD_U_0224::DoTestStepL()

 10830 	{

 10831 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

 10832 	TBool testOK = EFalse;

 10833 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCMU16ToPCM16OptimumDst));

 10835 	if (err)

 10836 		{

 10837 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10838 		return EFail;

 10839 		}

 10840 	else if (!testOK)

 10841 		{

 10842 		INFO_PRINTF1(_L("Test failed"));

 10843 		return EFail;

 10844 		}

 10845 	else

 10846 		return EPass;

 10847 	}

 10849 //------------------------------------------------------------------

 10851 /** @xxxx

 10852  * Constructor

 10853  */

 10854 CTest_MMF_ACOD_U_0225::CTest_MMF_ACOD_U_0225()

 10855 	{

 10856 	// store the name of this test case

 10857 	// this is the name that is used by the script file

 10858 	// Each test step initialises it's own name

 10859 	iTestStepName = _L("MM-MMF-ACOD-U-0225-HP");

 10861 	iExpectedLeaveErrorCode = KErrArgument;

 10862 	}

 10864 /** @xxxx

 10865  * PCMU16 to PCM16 Pass in zero sized destination buffer

 10866  * @test Req. under test REQ172.6.4, REQ172.6.5

 10867  */

 10868 TVerdict CTest_MMF_ACOD_U_0225::DoTestStepL()

 10869 	{

 10870 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

 10871 	TBool testOK = EFalse;

 10872 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCMU16ToPCM16OptimumSrc, 0));

 10874 	if (err)

 10875 		{

 10876 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10877 		return EFail;

 10878 		}

 10879 	else if (!testOK)

 10880 		{

 10881 		INFO_PRINTF1(_L("Test failed"));

 10882 		return EFail;

 10883 		}

 10884 	else

 10885 		return EPass;

 10886 	}

 10888 //------------------------------------------------------------------

 10890 /** @xxxx

 10891  * Constructor

 10892  */

 10893 CTest_MMF_ACOD_U_0226::CTest_MMF_ACOD_U_0226()

 10894 	{

 10895 	// store the name of this test case

 10896 	// this is the name that is used by the script file

 10897 	// Each test step initialises it's own name

 10898 	iTestStepName = _L("MM-MMF-ACOD-U-0226-HP");

 10899 	}

 10901 /** @xxxx

 10902  * PCMU16 to PCM16 Test out of memory

 10903  * @test Req. under test REQ172.11

 10904  */

 10905 TVerdict CTest_MMF_ACOD_U_0226::DoTestStepL()

 10906 	{

 10907 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

 10908 	TBool testOK = EFalse;

 10910 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 10911 	if (err==KErrNone && testOK)

 10912 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 10914 	if (err)

 10915 		{

 10916 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10917 		return EFail;

 10918 		}

 10919 	else if (!testOK)

 10920 		{

 10921 		INFO_PRINTF1(_L("Test failed"));

 10922 		return EFail;

 10923 		}

 10924 	else

 10925 		return EPass;

 10926 	}

 10928 //------------------------------------------------------------------

 10930 /** @xxxx

 10931  * Constructor

 10932  */

 10933 CTest_MMF_ACOD_U_0227::CTest_MMF_ACOD_U_0227()

 10934 	{

 10935 	// store the name of this test case

 10936 	// this is the name that is used by the script file

 10937 	// Each test step initialises it's own name

 10938 	iTestStepName = _L("MM-MMF-ACOD-U-0227-HP");

 10939 	}

 10941 /** @xxxx

 10942  * PCMU16 to PCM16 Test for memory leaks

 10943  * @test Req. under test REQ172.11

 10944  */

 10945 TVerdict CTest_MMF_ACOD_U_0227::DoTestStepL()

 10946 	{

 10947 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

 10948 	TBool testOK = EFalse;

 10949 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 10951 	if (err)

 10952 		{

 10953 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10954 		return EFail;

 10955 		}

 10956 	else if (!testOK)

 10957 		{

 10958 		INFO_PRINTF1(_L("Test failed"));

 10959 		return EFail;

 10960 		}

 10961 	else

 10962 		return EPass;

 10963 	}

 10965 //------------------------------------------------------------------

 10967 /** @xxxx

 10968  * Constructor

 10969  */

 10970 CTest_MMF_ACOD_U_0228::CTest_MMF_ACOD_U_0228()

 10971 	{

 10972 	// store the name of this test case

 10973 	// this is the name that is used by the script file

 10974 	// Each test step initialises it's own name

 10975 	iTestStepName = _L("MM-MMF-ACOD-U-0228-HP");

 10976 	}

 10978 /** @xxxx

 10979  * PCMU16 to PCM16 Test for memory scribbles

 10980  * @test Req. under test REQ172.11

 10981  */

 10982 TVerdict CTest_MMF_ACOD_U_0228::DoTestStepL()

 10983 	{

 10984 	const TUid codecUid = {KMmfUidCodecAudioU16ToPCMS16};

 10985 	TBool testOK = EFalse;

 10986 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 10988 	if (err)

 10989 		{

 10990 		INFO_PRINTF2(_L("Test left with status %d"), err);

 10991 		return EFail;

 10992 		}

 10993 	else if (!testOK)

 10994 		{

 10995 		INFO_PRINTF1(_L("Test failed"));

 10996 		return EFail;

 10997 		}

 10998 	else

 10999 		return EPass;

 11000 	}

 11002 //------------------------------------------------------------------

 11004 /** @xxxx

 11005  * Constructor

 11006  */

 11007 CTest_MMF_ACOD_U_0229::CTest_MMF_ACOD_U_0229()

 11008 	{

 11009 	// store the name of this test case

 11010 	// this is the name that is used by the script file

 11011 	// Each test step initialises it's own name

 11012 	iTestStepName = _L("MM-MMF-ACOD-U-0229-HP");

 11014 	for (TUint i=0; i<5; i++)

 11015 		{

 11016 		iExpectedSrcBytesProcessed[i] = 0;

 11017 		iExpectedDstBytesAdded[i] = 0;

 11018 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 11019 		}

 11020 	}

 11022 /** @xxxx

 11023  * PCMU8 To PCM16 Pass in zero sized source buffer

 11024  * @test Req. under test REQ172.6.4, REQ172.6.5

 11025  */

 11026 TVerdict CTest_MMF_ACOD_U_0229::DoTestStepL()

 11027 	{

 11028 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

 11029 	TBool testOK = EFalse;

 11030 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCMU8ToPCM16OptimumDst));

 11032 	if (err)

 11033 		{

 11034 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11035 		return EFail;

 11036 		}

 11037 	else if (!testOK)

 11038 		{

 11039 		INFO_PRINTF1(_L("Test failed"));

 11040 		return EFail;

 11041 		}

 11042 	else

 11043 		return EPass;

 11044 	}

 11046 //------------------------------------------------------------------

 11048 /** @xxxx

 11049  * Constructor

 11050  */

 11051 CTest_MMF_ACOD_U_0230::CTest_MMF_ACOD_U_0230()

 11052 	{

 11053 	// store the name of this test case

 11054 	// this is the name that is used by the script file

 11055 	// Each test step initialises it's own name

 11056 	iTestStepName = _L("MM-MMF-ACOD-U-0230-HP");

 11058 	iExpectedLeaveErrorCode = KErrArgument;

 11059 	}

 11061 /** @xxxx

 11062  * PCMU8 To PCM16 Pass in zero sized destination buffer

 11063  * @test Req. under test REQ172.6.4, REQ172.6.5

 11064  */

 11065 TVerdict CTest_MMF_ACOD_U_0230::DoTestStepL()

 11066 	{

 11067 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

 11068 	TBool testOK = EFalse;

 11069 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCMU8ToPCM16OptimumSrc, 0));

 11071 	if (err)

 11072 		{

 11073 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11074 		return EFail;

 11075 		}

 11076 	else if (!testOK)

 11077 		{

 11078 		INFO_PRINTF1(_L("Test failed"));

 11079 		return EFail;

 11080 		}

 11081 	else

 11082 		return EPass;

 11083 	}

 11085 //------------------------------------------------------------------

 11087 /** @xxxx

 11088  * Constructor

 11089  */

 11090 CTest_MMF_ACOD_U_0231::CTest_MMF_ACOD_U_0231()

 11091 	{

 11092 	// store the name of this test case

 11093 	// this is the name that is used by the script file

 11094 	// Each test step initialises it's own name

 11095 	iTestStepName = _L("MM-MMF-ACOD-U-0231-HP");

 11096 	}

 11098 /** @xxxx

 11099  * PCMU8 To PCM16 Test out of memory

 11100  * @test Req. under test REQ172.11

 11101  */

 11102 TVerdict CTest_MMF_ACOD_U_0231::DoTestStepL()

 11103 	{

 11104 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

 11105 	TBool testOK = EFalse;

 11107 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 11108 	if (err==KErrNone && testOK)

 11109 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 11111 	if (err)

 11112 		{

 11113 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11114 		return EFail;

 11115 		}

 11116 	else if (!testOK)

 11117 		{

 11118 		INFO_PRINTF1(_L("Test failed"));

 11119 		return EFail;

 11120 		}

 11121 	else

 11122 		return EPass;

 11123 	}

 11125 //------------------------------------------------------------------

 11128 /** @xxxx

 11129  * Constructor

 11130  */

 11131 CTest_MMF_ACOD_U_0232::CTest_MMF_ACOD_U_0232()

 11132 	{

 11133 	// store the name of this test case

 11134 	// this is the name that is used by the script file

 11135 	// Each test step initialises it's own name

 11136 	iTestStepName = _L("MM-MMF-ACOD-U-0232-HP");

 11137 	}

 11139 /** @xxxx

 11140  * PCMU8 To PCM16 Test for memory leaks

 11141  * @test Req. under test REQ172.11

 11142  */

 11143 TVerdict CTest_MMF_ACOD_U_0232::DoTestStepL()

 11144 	{

 11145 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

 11146 	TBool testOK = EFalse;

 11147 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 11149 	if (err)

 11150 		{

 11151 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11152 		return EFail;

 11153 		}

 11154 	else if (!testOK)

 11155 		{

 11156 		INFO_PRINTF1(_L("Test failed"));

 11157 		return EFail;

 11158 		}

 11159 	else

 11160 		return EPass;

 11161 	}

 11163 //------------------------------------------------------------------

 11166 /** @xxxx

 11167  * Constructor

 11168  */

 11169 CTest_MMF_ACOD_U_0233::CTest_MMF_ACOD_U_0233()

 11170 	{

 11171 	// store the name of this test case

 11172 	// this is the name that is used by the script file

 11173 	// Each test step initialises it's own name

 11174 	iTestStepName = _L("MM-MMF-ACOD-U-0233-HP");

 11175 	}

 11177 /** @xxxx

 11178  * PCMU8 To PCM16 Test for memory scribbles

 11179  * @test Req. under test REQ172.11

 11180  */

 11181 TVerdict CTest_MMF_ACOD_U_0233::DoTestStepL()

 11182 	{

 11183 	const TUid codecUid = {KMmfUidCodecAudioU8ToPCMS16};

 11184 	TBool testOK = EFalse;

 11185 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 11187 	if (err)

 11188 		{

 11189 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11190 		return EFail;

 11191 		}

 11192 	else if (!testOK)

 11193 		{

 11194 		INFO_PRINTF1(_L("Test failed"));

 11195 		return EFail;

 11196 		}

 11197 	else

 11198 		return EPass;

 11199 	}

 11201 //------------------------------------------------------------------

 11203 /** @xxxx

 11204  * Constructor

 11205  */

 11206 CTest_MMF_ACOD_U_0234::CTest_MMF_ACOD_U_0234()

 11207 	{

 11208 	// store the name of this test case

 11209 	// this is the name that is used by the script file

 11210 	// Each test step initialises it's own name

 11211 	iTestStepName = _L("MM-MMF-ACOD-U-0234-HP");

 11213 	for (TUint i=0; i<5; i++)

 11214 		{

 11215 		iExpectedSrcBytesProcessed[i] = 0;

 11216 		iExpectedDstBytesAdded[i] = 0;

 11217 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 11218 		}

 11219 	}

 11221 /** @xxxx

 11222  * MULAW To PCM16 Pass in zero sized source buffer

 11223  * @test Req. under test REQ172.6.4, REQ172.6.5

 11224  */

 11225 TVerdict CTest_MMF_ACOD_U_0234::DoTestStepL()

 11226 	{

 11227 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

 11228 	TBool testOK = EFalse;

 11229 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KMulawToPCM16OptimumDst));

 11231 	if (err)

 11232 		{

 11233 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11234 		return EFail;

 11235 		}

 11236 	else if (!testOK)

 11237 		{

 11238 		INFO_PRINTF1(_L("Test failed"));

 11239 		return EFail;

 11240 		}

 11241 	else

 11242 		return EPass;

 11243 	}

 11245 //------------------------------------------------------------------

 11247 /** @xxxx

 11248  * Constructor

 11249  */

 11250 CTest_MMF_ACOD_U_0235::CTest_MMF_ACOD_U_0235()

 11251 	{

 11252 	// store the name of this test case

 11253 	// this is the name that is used by the script file

 11254 	// Each test step initialises it's own name

 11255 	iTestStepName = _L("MM-MMF-ACOD-U-0235-HP");

 11257 	iExpectedLeaveErrorCode = KErrArgument;

 11258 	}

 11260 /** @xxxx

 11261  * MULAW To PCM16 Pass in zero sized destination buffer

 11262  * @test Req. under test REQ172.6.4, REQ172.6.5

 11263  */

 11264 TVerdict CTest_MMF_ACOD_U_0235::DoTestStepL()

 11265 	{

 11266 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

 11267 	TBool testOK = EFalse;

 11268 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KMulawToPCM16OptimumSrc, 0));

 11270 	if (err)

 11271 		{

 11272 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11273 		return EFail;

 11274 		}

 11275 	else if (!testOK)

 11276 		{

 11277 		INFO_PRINTF1(_L("Test failed"));

 11278 		return EFail;

 11279 		}

 11280 	else

 11281 		return EPass;

 11282 	}

 11284 //------------------------------------------------------------------

 11286 /** @xxxx

 11287  * Constructor

 11288  */

 11289 CTest_MMF_ACOD_U_0236::CTest_MMF_ACOD_U_0236()

 11290 	{

 11291 	// store the name of this test case

 11292 	// this is the name that is used by the script file

 11293 	// Each test step initialises it's own name

 11294 	iTestStepName = _L("MM-MMF-ACOD-U-0236-HP");

 11295 	}

 11297 /** @xxxx

 11298  * MULAW To PCM16 Test out of memory

 11299  * @test Req. under test REQ172.11

 11300  */

 11301 TVerdict CTest_MMF_ACOD_U_0236::DoTestStepL()

 11302 	{

 11303 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

 11304 	TBool testOK = EFalse;

 11306 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 11307 	if (err==KErrNone && testOK)

 11308 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 11310 	if (err)

 11311 		{

 11312 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11313 		return EFail;

 11314 		}

 11315 	else if (!testOK)

 11316 		{

 11317 		INFO_PRINTF1(_L("Test failed"));

 11318 		return EFail;

 11319 		}

 11320 	else

 11321 		return EPass;

 11322 	}

 11324 //------------------------------------------------------------------

 11327 /** @xxxx

 11328  * Constructor

 11329  */

 11330 CTest_MMF_ACOD_U_0237::CTest_MMF_ACOD_U_0237()

 11331 	{

 11332 	// store the name of this test case

 11333 	// this is the name that is used by the script file

 11334 	// Each test step initialises it's own name

 11335 	iTestStepName = _L("MM-MMF-ACOD-U-0237-HP");

 11336 	}

 11338 /** @xxxx

 11339  * MULAW To PCM16 Test for memory leaks

 11340  * @test Req. under test REQ172.11

 11341  */

 11342 TVerdict CTest_MMF_ACOD_U_0237::DoTestStepL()

 11343 	{

 11344 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

 11345 	TBool testOK = EFalse;

 11346 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 11348 	if (err)

 11349 		{

 11350 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11351 		return EFail;

 11352 		}

 11353 	else if (!testOK)

 11354 		{

 11355 		INFO_PRINTF1(_L("Test failed"));

 11356 		return EFail;

 11357 		}

 11358 	else

 11359 		return EPass;

 11360 	}

 11362 //------------------------------------------------------------------

 11365 /** @xxxx

 11366  * Constructor

 11367  */

 11368 CTest_MMF_ACOD_U_0238::CTest_MMF_ACOD_U_0238()

 11369 	{

 11370 	// store the name of this test case

 11371 	// this is the name that is used by the script file

 11372 	// Each test step initialises it's own name

 11373 	iTestStepName = _L("MM-MMF-ACOD-U-0238-HP");

 11374 	}

 11376 /** @xxxx

 11377  * MULAW To PCM16 Test for memory scribbles

 11378  * @test Req. under test REQ172.11

 11379  */

 11380 TVerdict CTest_MMF_ACOD_U_0238::DoTestStepL()

 11381 	{

 11382 	const TUid codecUid = {KMmfUidCodecMulawToPCM16};

 11383 	TBool testOK = EFalse;

 11384 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 11386 	if (err)

 11387 		{

 11388 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11389 		return EFail;

 11390 		}

 11391 	else if (!testOK)

 11392 		{

 11393 		INFO_PRINTF1(_L("Test failed"));

 11394 		return EFail;

 11395 		}

 11396 	else

 11397 		return EPass;

 11398 	}

 11400 //------------------------------------------------------------------

 11402 /** @xxxx

 11403  * Constructor

 11404  */

 11405 CTest_MMF_ACOD_U_0239::CTest_MMF_ACOD_U_0239()

 11406 	{

 11407 	// store the name of this test case

 11408 	// this is the name that is used by the script file

 11409 	// Each test step initialises it's own name

 11410 	iTestStepName = _L("MM-MMF-ACOD-U-0239-HP");

 11412 	for (TUint i=0; i<5; i++)

 11413 		{

 11414 		iExpectedSrcBytesProcessed[i] = 0;

 11415 		iExpectedDstBytesAdded[i] = 0;

 11416 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 11417 		}

 11418 	}

 11420 /** @xxxx

 11421  * PCM16 to MULAW Pass in zero sized source buffer

 11422  * @test Req. under test REQ172.6.4, REQ172.6.5

 11423  */

 11424 TVerdict CTest_MMF_ACOD_U_0239::DoTestStepL()

 11425 	{

 11426 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

 11427 	TBool testOK = EFalse;

 11428 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToMulawOptimumDst));

 11430 	if (err)

 11431 		{

 11432 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11433 		return EFail;

 11434 		}

 11435 	else if (!testOK)

 11436 		{

 11437 		INFO_PRINTF1(_L("Test failed"));

 11438 		return EFail;

 11439 		}

 11440 	else

 11441 		return EPass;

 11442 	}

 11444 //------------------------------------------------------------------

 11446 /** @xxxx

 11447  * Constructor

 11448  */

 11449 CTest_MMF_ACOD_U_0240::CTest_MMF_ACOD_U_0240()

 11450 	{

 11451 	// store the name of this test case

 11452 	// this is the name that is used by the script file

 11453 	// Each test step initialises it's own name

 11454 	iTestStepName = _L("MM-MMF-ACOD-U-0240-HP");

 11456 	iExpectedLeaveErrorCode = KErrArgument;

 11457 	}

 11459 /** @xxxx

 11460  * PCM16 to MULAW Pass in zero sized destination buffer

 11461  * @test Req. under test REQ172.6.4, REQ172.6.5

 11462  */

 11463 TVerdict CTest_MMF_ACOD_U_0240::DoTestStepL()

 11464 	{

 11465 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

 11466 	TBool testOK = EFalse;

 11467 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToMulawOptimumSrc, 0));

 11469 	if (err)

 11470 		{

 11471 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11472 		return EFail;

 11473 		}

 11474 	else if (!testOK)

 11475 		{

 11476 		INFO_PRINTF1(_L("Test failed"));

 11477 		return EFail;

 11478 		}

 11479 	else

 11480 		return EPass;

 11481 	}

 11483 //------------------------------------------------------------------

 11485 /** @xxxx

 11486  * Constructor

 11487  */

 11488 CTest_MMF_ACOD_U_0241::CTest_MMF_ACOD_U_0241()

 11489 	{

 11490 	// store the name of this test case

 11491 	// this is the name that is used by the script file

 11492 	// Each test step initialises it's own name

 11493 	iTestStepName = _L("MM-MMF-ACOD-U-0241-HP");

 11494 	}

 11496 /** @xxxx

 11497  * PCM16 to MULAW Test out of memory

 11498  * @test Req. under test REQ172.11

 11499  */

 11500 TVerdict CTest_MMF_ACOD_U_0241::DoTestStepL()

 11501 	{

 11502 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

 11503 	TBool testOK = EFalse;

 11505 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 11506 	if (err==KErrNone && testOK)

 11507 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 11509 	if (err)

 11510 		{

 11511 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11512 		return EFail;

 11513 		}

 11514 	else if (!testOK)

 11515 		{

 11516 		INFO_PRINTF1(_L("Test failed"));

 11517 		return EFail;

 11518 		}

 11519 	else

 11520 		return EPass;

 11521 	}

 11523 //------------------------------------------------------------------

 11526 /** @xxxx

 11527  * Constructor

 11528  */

 11529 CTest_MMF_ACOD_U_0242::CTest_MMF_ACOD_U_0242()

 11530 	{

 11531 	// store the name of this test case

 11532 	// this is the name that is used by the script file

 11533 	// Each test step initialises it's own name

 11534 	iTestStepName = _L("MM-MMF-ACOD-U-0242-HP");

 11535 	}

 11537 /** @xxxx

 11538  * PCM16 to MULAW Test for memory leaks

 11539  * @test Req. under test REQ172.11

 11540  */

 11541 TVerdict CTest_MMF_ACOD_U_0242::DoTestStepL()

 11542 	{

 11543 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

 11544 	TBool testOK = EFalse;

 11545 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 11547 	if (err)

 11548 		{

 11549 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11550 		return EFail;

 11551 		}

 11552 	else if (!testOK)

 11553 		{

 11554 		INFO_PRINTF1(_L("Test failed"));

 11555 		return EFail;

 11556 		}

 11557 	else

 11558 		return EPass;

 11559 	}

 11561 //------------------------------------------------------------------

 11564 /** @xxxx

 11565  * Constructor

 11566  */

 11567 CTest_MMF_ACOD_U_0243::CTest_MMF_ACOD_U_0243()

 11568 	{

 11569 	// store the name of this test case

 11570 	// this is the name that is used by the script file

 11571 	// Each test step initialises it's own name

 11572 	iTestStepName = _L("MM-MMF-ACOD-U-0243-HP");

 11573 	}

 11575 /** @xxxx

 11576  * PCM16 to MULAW Test for memory scribbles

 11577  * @test Req. under test REQ172.11

 11578  */

 11579 TVerdict CTest_MMF_ACOD_U_0243::DoTestStepL()

 11580 	{

 11581 	const TUid codecUid = {KMmfUidCodecPCM16ToMulaw};

 11582 	TBool testOK = EFalse;

 11583 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 11585 	if (err)

 11586 		{

 11587 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11588 		return EFail;

 11589 		}

 11590 	else if (!testOK)

 11591 		{

 11592 		INFO_PRINTF1(_L("Test failed"));

 11593 		return EFail;

 11594 		}

 11595 	else

 11596 		return EPass;

 11597 	}

 11599 //------------------------------------------------------------------

 11601 /** @xxxx

 11602  * Constructor

 11603  */

 11604 CTest_MMF_ACOD_U_0244::CTest_MMF_ACOD_U_0244()

 11605 	{

 11606 	// store the name of this test case

 11607 	// this is the name that is used by the script file

 11608 	// Each test step initialises it's own name

 11609 	iTestStepName = _L("MM-MMF-ACOD-U-0244-HP");

 11611 	for (TUint i=0; i<5; i++)

 11612 		{

 11613 		iExpectedSrcBytesProcessed[i] = 0;

 11614 		iExpectedDstBytesAdded[i] = 0;

 11615 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 11616 		}

 11617 	}

 11619 /** @xxxx

 11620  * IMAD To PCM16 Pass in zero sized source buffer

 11621  * @test Req. under test REQ172.6.4, REQ172.6.5

 11622  */

 11623 TVerdict CTest_MMF_ACOD_U_0244::DoTestStepL()

 11624 	{

 11625 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

 11626 	TBool testOK = EFalse;

 11627 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KAdpcmToPCM16OptimumDst));

 11629 	if (err)

 11630 		{

 11631 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11632 		return EFail;

 11633 		}

 11634 	else if (!testOK)

 11635 		{

 11636 		INFO_PRINTF1(_L("Test failed"));

 11637 		return EFail;

 11638 		}

 11639 	else

 11640 		return EPass;

 11641 	}

 11643 //------------------------------------------------------------------

 11645 /** @xxxx

 11646  * Constructor

 11647  */

 11648 CTest_MMF_ACOD_U_0245::CTest_MMF_ACOD_U_0245()

 11649 	{

 11650 	// store the name of this test case

 11651 	// this is the name that is used by the script file

 11652 	// Each test step initialises it's own name

 11653 	iTestStepName = _L("MM-MMF-ACOD-U-0245-HP");

 11655 	iExpectedLeaveErrorCode = KErrArgument;

 11656 	}

 11658 /** @xxxx

 11659  * IMAD To PCM16 Pass in zero sized destination buffer

 11660  * @test Req. under test REQ172.6.4, REQ172.6.5

 11661  */

 11662 TVerdict CTest_MMF_ACOD_U_0245::DoTestStepL()

 11663 	{

 11664 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

 11665 	TBool testOK = EFalse;

 11666 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KAdpcmToPCM16OptimumSrc, 0));

 11668 	if (err)

 11669 		{

 11670 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11671 		return EFail;

 11672 		}

 11673 	else if (!testOK)

 11674 		{

 11675 		INFO_PRINTF1(_L("Test failed"));

 11676 		return EFail;

 11677 		}

 11678 	else

 11679 		return EPass;

 11680 	}

 11682 //------------------------------------------------------------------

 11684 /** @xxxx

 11685  * Constructor

 11686  */

 11687 CTest_MMF_ACOD_U_0246::CTest_MMF_ACOD_U_0246()

 11688 	{

 11689 	// store the name of this test case

 11690 	// this is the name that is used by the script file

 11691 	// Each test step initialises it's own name

 11692 	iTestStepName = _L("MM-MMF-ACOD-U-0246-HP");

 11693 	}

 11695 /** @xxxx

 11696  * IMAD To PCM16 Test out of memory

 11697  * @test Req. under test REQ172.11

 11698  */

 11699 TVerdict CTest_MMF_ACOD_U_0246::DoTestStepL()

 11700 	{

 11701 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

 11702 	TBool testOK = EFalse;

 11704 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 11705 	if (err==KErrNone && testOK)

 11706 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 11708 	if (err)

 11709 		{

 11710 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11711 		return EFail;

 11712 		}

 11713 	else if (!testOK)

 11714 		{

 11715 		INFO_PRINTF1(_L("Test failed"));

 11716 		return EFail;

 11717 		}

 11718 	else

 11719 		return EPass;

 11720 	}

 11722 //------------------------------------------------------------------

 11724 /** @xxxx

 11725  * Constructor

 11726  */

 11727 CTest_MMF_ACOD_U_0247::CTest_MMF_ACOD_U_0247()

 11728 	{

 11729 	// store the name of this test case

 11730 	// this is the name that is used by the script file

 11731 	// Each test step initialises it's own name

 11732 	iTestStepName = _L("MM-MMF-ACOD-U-0247-HP");

 11733 	}

 11735 /** @xxxx

 11736  * IMAD To PCM16 Test for memory leaks

 11737  * @test Req. under test REQ172.11

 11738  */

 11739 TVerdict CTest_MMF_ACOD_U_0247::DoTestStepL()

 11740 	{

 11741 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

 11742 	TBool testOK = EFalse;

 11743 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 11745 	if (err)

 11746 		{

 11747 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11748 		return EFail;

 11749 		}

 11750 	else if (!testOK)

 11751 		{

 11752 		INFO_PRINTF1(_L("Test failed"));

 11753 		return EFail;

 11754 		}

 11755 	else

 11756 		return EPass;

 11757 	}

 11759 //------------------------------------------------------------------

 11761 /** @xxxx

 11762  * Constructor

 11763  */

 11764 CTest_MMF_ACOD_U_0248::CTest_MMF_ACOD_U_0248()

 11765 	{

 11766 	// store the name of this test case

 11767 	// this is the name that is used by the script file

 11768 	// Each test step initialises it's own name

 11769 	iTestStepName = _L("MM-MMF-ACOD-U-0248-HP");

 11770 	}

 11772 /** @xxxx

 11773  * IMAD To PCM16 Test for memory scribbles

 11774  * @test Req. under test REQ172.11

 11775  */

 11776 TVerdict CTest_MMF_ACOD_U_0248::DoTestStepL()

 11777 	{

 11778 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16};

 11779 	TBool testOK = EFalse;

 11780 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 11782 	if (err)

 11783 		{

 11784 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11785 		return EFail;

 11786 		}

 11787 	else if (!testOK)

 11788 		{

 11789 		INFO_PRINTF1(_L("Test failed"));

 11790 		return EFail;

 11791 		}

 11792 	else

 11793 		return EPass;

 11794 	}

 11796 //------------------------------------------------------------------

 11798 /** @xxxx

 11799  * Constructor

 11800  */

 11801 CTest_MMF_ACOD_U_0249::CTest_MMF_ACOD_U_0249()

 11802 	{

 11803 	// store the name of this test case

 11804 	// this is the name that is used by the script file

 11805 	// Each test step initialises it's own name

 11806 	iTestStepName = _L("MM-MMF-ACOD-U-0249-HP");

 11808 	for (TUint i=0; i<5; i++)

 11809 		{

 11810 		iExpectedSrcBytesProcessed[i] = 0;

 11811 		iExpectedDstBytesAdded[i] = 0;

 11812 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 11813 		}

 11814 	}

 11816 /** @xxxx

 11817  * PCM16 to IMAD Pass in zero sized source buffer

 11818  * @test Req. under test REQ172.6.4, REQ172.6.5

 11819  */

 11820 TVerdict CTest_MMF_ACOD_U_0249::DoTestStepL()

 11821 	{

 11822 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

 11823 	TBool testOK = EFalse;

 11824 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToAdpcmOptimumDst));

 11826 	if (err)

 11827 		{

 11828 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11829 		return EFail;

 11830 		}

 11831 	else if (!testOK)

 11832 		{

 11833 		INFO_PRINTF1(_L("Test failed"));

 11834 		return EFail;

 11835 		}

 11836 	else

 11837 		return EPass;

 11838 	}

 11840 //------------------------------------------------------------------

 11842 /** @xxxx

 11843  * Constructor

 11844  */

 11845 CTest_MMF_ACOD_U_0250::CTest_MMF_ACOD_U_0250()

 11846 	{

 11847 	// store the name of this test case

 11848 	// this is the name that is used by the script file

 11849 	// Each test step initialises it's own name

 11850 	iTestStepName = _L("MM-MMF-ACOD-U-0250-HP");

 11852 	iExpectedLeaveErrorCode = KErrArgument;

 11853 	}

 11855 /** @xxxx

 11856  * PCM16 to IMAD Pass in zero sized destination buffer

 11857  * @test Req. under test REQ172.6.4, REQ172.6.5

 11858  */

 11859 TVerdict CTest_MMF_ACOD_U_0250::DoTestStepL()

 11860 	{

 11861 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

 11862 	TBool testOK = EFalse;

 11863 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToAdpcmOptimumSrc, 0));

 11865 	if (err)

 11866 		{

 11867 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11868 		return EFail;

 11869 		}

 11870 	else if (!testOK)

 11871 		{

 11872 		INFO_PRINTF1(_L("Test failed"));

 11873 		return EFail;

 11874 		}

 11875 	else

 11876 		return EPass;

 11877 	}

 11879 //------------------------------------------------------------------

 11881 /** @xxxx

 11882  * Constructor

 11883  */

 11884 CTest_MMF_ACOD_U_0251::CTest_MMF_ACOD_U_0251()

 11885 	{

 11886 	// store the name of this test case

 11887 	// this is the name that is used by the script file

 11888 	// Each test step initialises it's own name

 11889 	iTestStepName = _L("MM-MMF-ACOD-U-0251-HP");

 11890 	}

 11892 /** @xxxx

 11893  * PCM16 to IMAD Test out of memory

 11894  * @test Req. under test REQ172.11

 11895  */

 11896 TVerdict CTest_MMF_ACOD_U_0251::DoTestStepL()

 11897 	{

 11898 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

 11899 	TBool testOK = EFalse;

 11901 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 11902 	if (err==KErrNone && testOK)

 11903 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 11905 	if (err)

 11906 		{

 11907 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11908 		return EFail;

 11909 		}

 11910 	else if (!testOK)

 11911 		{

 11912 		INFO_PRINTF1(_L("Test failed"));

 11913 		return EFail;

 11914 		}

 11915 	else

 11916 		return EPass;

 11917 	}

 11919 //------------------------------------------------------------------

 11922 /** @xxxx

 11923  * Constructor

 11924  */

 11925 CTest_MMF_ACOD_U_0252::CTest_MMF_ACOD_U_0252()

 11926 	{

 11927 	// store the name of this test case

 11928 	// this is the name that is used by the script file

 11929 	// Each test step initialises it's own name

 11930 	iTestStepName = _L("MM-MMF-ACOD-U-0252-HP");

 11931 	}

 11933 /** @xxxx

 11934  * PCM16 to IMAD Test for memory leaks

 11935  * @test Req. under test REQ172.11

 11936  */

 11937 TVerdict CTest_MMF_ACOD_U_0252::DoTestStepL()

 11938 	{

 11939 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

 11940 	TBool testOK = EFalse;

 11941 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 11943 	if (err)

 11944 		{

 11945 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11946 		return EFail;

 11947 		}

 11948 	else if (!testOK)

 11949 		{

 11950 		INFO_PRINTF1(_L("Test failed"));

 11951 		return EFail;

 11952 		}

 11953 	else

 11954 		return EPass;

 11955 	}

 11957 //------------------------------------------------------------------

 11959 /** @xxxx

 11960  * Constructor

 11961  */

 11962 CTest_MMF_ACOD_U_0253::CTest_MMF_ACOD_U_0253()

 11963 	{

 11964 	// store the name of this test case

 11965 	// this is the name that is used by the script file

 11966 	// Each test step initialises it's own name

 11967 	iTestStepName = _L("MM-MMF-ACOD-U-0253-HP");

 11968 	}

 11970 /** @xxxx

 11971  * PCM16 to IMAD Test for memory scribbles

 11972  * @test Req. under test REQ172.11

 11973  */

 11974 TVerdict CTest_MMF_ACOD_U_0253::DoTestStepL()

 11975 	{

 11976 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCM};

 11977 	TBool testOK = EFalse;

 11978 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 11980 	if (err)

 11981 		{

 11982 		INFO_PRINTF2(_L("Test left with status %d"), err);

 11983 		return EFail;

 11984 		}

 11985 	else if (!testOK)

 11986 		{

 11987 		INFO_PRINTF1(_L("Test failed"));

 11988 		return EFail;

 11989 		}

 11990 	else

 11991 		return EPass;

 11992 	}

 11994 //------------------------------------------------------------------

 11996 /** @xxxx

 11997  * Constructor

 11998  */

 11999 CTest_MMF_ACOD_U_0254::CTest_MMF_ACOD_U_0254()

 12000 	{

 12001 	// store the name of this test case

 12002 	// this is the name that is used by the script file

 12003 	// Each test step initialises it's own name

 12004 	iTestStepName = _L("MM-MMF-ACOD-U-0254-HP");

 12006 	for (TUint i=0; i<5; i++)

 12007 		{

 12008 		iExpectedSrcBytesProcessed[i] = 0;

 12009 		iExpectedDstBytesAdded[i] = 0;

 12010 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 12011 		}

 12012 	}

 12014 /** @xxxx

 12015  * IMAS To PCM16 Pass in zero sized source buffer

 12016  * @test Req. under test REQ172.6.4, REQ172.6.5

 12017  */

 12018 TVerdict CTest_MMF_ACOD_U_0254::DoTestStepL()

 12019 	{

 12020 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

 12021 	TBool testOK = EFalse;

 12022 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KStereoAdpcmToPCM16OptimumDst));

 12024 	if (err)

 12025 		{

 12026 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12027 		return EFail;

 12028 		}

 12029 	else if (!testOK)

 12030 		{

 12031 		INFO_PRINTF1(_L("Test failed"));

 12032 		return EFail;

 12033 		}

 12034 	else

 12035 		return EPass;

 12036 	}

 12038 //------------------------------------------------------------------

 12040 /** @xxxx

 12041  * Constructor

 12042  */

 12043 CTest_MMF_ACOD_U_0255::CTest_MMF_ACOD_U_0255()

 12044 	{

 12045 	// store the name of this test case

 12046 	// this is the name that is used by the script file

 12047 	// Each test step initialises it's own name

 12048 	iTestStepName = _L("MM-MMF-ACOD-U-0255-HP");

 12050 	iExpectedLeaveErrorCode = KErrArgument;

 12051 	}

 12053 /** @xxxx

 12054  * IMAS To PCM16 Pass in zero sized destination buffer

 12055  * @test Req. under test REQ172.6.4, REQ172.6.5

 12056  */

 12057 TVerdict CTest_MMF_ACOD_U_0255::DoTestStepL()

 12058 	{

 12059 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

 12060 	TBool testOK = EFalse;

 12061 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KStereoAdpcmToPCM16OptimumSrc, 0));

 12063 	if (err)

 12064 		{

 12065 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12066 		return EFail;

 12067 		}

 12068 	else if (!testOK)

 12069 		{

 12070 		INFO_PRINTF1(_L("Test failed"));

 12071 		return EFail;

 12072 		}

 12073 	else

 12074 		return EPass;

 12075 	}

 12077 //------------------------------------------------------------------

 12079 /** @xxxx

 12080  * Constructor

 12081  */

 12082 CTest_MMF_ACOD_U_0256::CTest_MMF_ACOD_U_0256()

 12083 	{

 12084 	// store the name of this test case

 12085 	// this is the name that is used by the script file

 12086 	// Each test step initialises it's own name

 12087 	iTestStepName = _L("MM-MMF-ACOD-U-0256-HP");

 12088 	}

 12090 /** @xxxx

 12091  * IMAS To PCM16 Test out of memory

 12092  * @test Req. under test REQ172.11

 12093  */

 12094 TVerdict CTest_MMF_ACOD_U_0256::DoTestStepL()

 12095 	{

 12096 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

 12097 	TBool testOK = EFalse;

 12099 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 12100 	if (err==KErrNone && testOK)

 12101 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 12103 	if (err)

 12104 		{

 12105 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12106 		return EFail;

 12107 		}

 12108 	else if (!testOK)

 12109 		{

 12110 		INFO_PRINTF1(_L("Test failed"));

 12111 		return EFail;

 12112 		}

 12113 	else

 12114 		return EPass;

 12115 	}

 12117 //------------------------------------------------------------------

 12119 /** @xxxx

 12120  * Constructor

 12121  */

 12122 CTest_MMF_ACOD_U_0257::CTest_MMF_ACOD_U_0257()

 12123 	{

 12124 	// store the name of this test case

 12125 	// this is the name that is used by the script file

 12126 	// Each test step initialises it's own name

 12127 	iTestStepName = _L("MM-MMF-ACOD-U-0257-HP");

 12128 	}

 12130 /** @xxxx

 12131  * IMAS To PCM16 Test for memory leaks

 12132  * @test Req. under test REQ172.11

 12133  */

 12134 TVerdict CTest_MMF_ACOD_U_0257::DoTestStepL()

 12135 	{

 12136 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

 12137 	TBool testOK = EFalse;

 12138 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 12140 	if (err)

 12141 		{

 12142 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12143 		return EFail;

 12144 		}

 12145 	else if (!testOK)

 12146 		{

 12147 		INFO_PRINTF1(_L("Test failed"));

 12148 		return EFail;

 12149 		}

 12150 	else

 12151 		return EPass;

 12152 	}

 12154 //------------------------------------------------------------------

 12156 /** @xxxx

 12157  * Constructor

 12158  */

 12159 CTest_MMF_ACOD_U_0258::CTest_MMF_ACOD_U_0258()

 12160 	{

 12161 	// store the name of this test case

 12162 	// this is the name that is used by the script file

 12163 	// Each test step initialises it's own name

 12164 	iTestStepName = _L("MM-MMF-ACOD-U-0258-HP");

 12165 	}

 12167 /** @xxxx

 12168  * IMAS To PCM16 Test for memory scribbles

 12169  * @test Req. under test REQ172.11

 12170  */

 12171 TVerdict CTest_MMF_ACOD_U_0258::DoTestStepL()

 12172 	{

 12173 	const TUid codecUid = {KMmfUidCodecIMAADPCMToPCM16Stereo};

 12174 	TBool testOK = EFalse;

 12175 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 12177 	if (err)

 12178 		{

 12179 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12180 		return EFail;

 12181 		}

 12182 	else if (!testOK)

 12183 		{

 12184 		INFO_PRINTF1(_L("Test failed"));

 12185 		return EFail;

 12186 		}

 12187 	else

 12188 		return EPass;

 12189 	}

 12191 //------------------------------------------------------------------

 12193 /** @xxxx

 12194  * Constructor

 12195  */

 12196 CTest_MMF_ACOD_U_0259::CTest_MMF_ACOD_U_0259()

 12197 	{

 12198 	// store the name of this test case

 12199 	// this is the name that is used by the script file

 12200 	// Each test step initialises it's own name

 12201 	iTestStepName = _L("MM-MMF-ACOD-U-0259-HP");

 12203 	for (TUint i=0; i<5; i++)

 12204 		{

 12205 		iExpectedSrcBytesProcessed[i] = 0;

 12206 		iExpectedDstBytesAdded[i] = 0;

 12207 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 12208 		}

 12209 	}

 12211 /** @xxxx

 12212  * PCM16 to IMAS Pass in zero sized source buffer

 12213  * @test Req. under test REQ172.6.4, REQ172.6.5

 12214  */

 12215 TVerdict CTest_MMF_ACOD_U_0259::DoTestStepL()

 12216 	{

 12217 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

 12218 	TBool testOK = EFalse;

 12219 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToStereoAdpcmOptimumDst));

 12221 	if (err)

 12222 		{

 12223 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12224 		return EFail;

 12225 		}

 12226 	else if (!testOK)

 12227 		{

 12228 		INFO_PRINTF1(_L("Test failed"));

 12229 		return EFail;

 12230 		}

 12231 	else

 12232 		return EPass;

 12233 	}

 12235 //------------------------------------------------------------------

 12237 /** @xxxx

 12238  * Constructor

 12239  */

 12240 CTest_MMF_ACOD_U_0260::CTest_MMF_ACOD_U_0260()

 12241 	{

 12242 	// store the name of this test case

 12243 	// this is the name that is used by the script file

 12244 	// Each test step initialises it's own name

 12245 	iTestStepName = _L("MM-MMF-ACOD-U-0260-HP");

 12247 	iExpectedLeaveErrorCode = KErrArgument;

 12248 	}

 12250 /** @xxxx

 12251  * PCM16 to IMAS Pass in zero sized destination buffer

 12252  * @test Req. under test REQ172.6.4, REQ172.6.5

 12253  */

 12254 TVerdict CTest_MMF_ACOD_U_0260::DoTestStepL()

 12255 	{

 12256 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

 12257 	TBool testOK = EFalse;

 12258 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToStereoAdpcmOptimumSrc, 0));

 12260 	if (err)

 12261 		{

 12262 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12263 		return EFail;

 12264 		}

 12265 	else if (!testOK)

 12266 		{

 12267 		INFO_PRINTF1(_L("Test failed"));

 12268 		return EFail;

 12269 		}

 12270 	else

 12271 		return EPass;

 12272 	}

 12274 //------------------------------------------------------------------

 12276 /** @xxxx

 12277  * Constructor

 12278  */

 12279 CTest_MMF_ACOD_U_0261::CTest_MMF_ACOD_U_0261()

 12280 	{

 12281 	// store the name of this test case

 12282 	// this is the name that is used by the script file

 12283 	// Each test step initialises it's own name

 12284 	iTestStepName = _L("MM-MMF-ACOD-U-0261-HP");

 12285 	}

 12287 /** @xxxx

 12288  * PCM16 to IMAS Test out of memory

 12289  * @test Req. under test REQ172.11

 12290  */

 12291 TVerdict CTest_MMF_ACOD_U_0261::DoTestStepL()

 12292 	{

 12293 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

 12294 	TBool testOK = EFalse;

 12296 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 12297 	if (err==KErrNone && testOK)

 12298 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 12300 	if (err)

 12301 		{

 12302 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12303 		return EFail;

 12304 		}

 12305 	else if (!testOK)

 12306 		{

 12307 		INFO_PRINTF1(_L("Test failed"));

 12308 		return EFail;

 12309 		}

 12310 	else

 12311 		return EPass;

 12312 	}

 12314 //------------------------------------------------------------------

 12317 /** @xxxx

 12318  * Constructor

 12319  */

 12320 CTest_MMF_ACOD_U_0262::CTest_MMF_ACOD_U_0262()

 12321 	{

 12322 	// store the name of this test case

 12323 	// this is the name that is used by the script file

 12324 	// Each test step initialises it's own name

 12325 	iTestStepName = _L("MM-MMF-ACOD-U-0262-HP");

 12326 	}

 12328 /** @xxxx

 12329  * PCM16 to IMAS Test for memory leaks

 12330  * @test Req. under test REQ172.11

 12331  */

 12332 TVerdict CTest_MMF_ACOD_U_0262::DoTestStepL()

 12333 	{

 12334 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

 12335 	TBool testOK = EFalse;

 12336 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 12338 	if (err)

 12339 		{

 12340 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12341 		return EFail;

 12342 		}

 12343 	else if (!testOK)

 12344 		{

 12345 		INFO_PRINTF1(_L("Test failed"));

 12346 		return EFail;

 12347 		}

 12348 	else

 12349 		return EPass;

 12350 	}

 12352 //------------------------------------------------------------------

 12354 /** @xxxx

 12355  * Constructor

 12356  */

 12357 CTest_MMF_ACOD_U_0263::CTest_MMF_ACOD_U_0263()

 12358 	{

 12359 	// store the name of this test case

 12360 	// this is the name that is used by the script file

 12361 	// Each test step initialises it's own name

 12362 	iTestStepName = _L("MM-MMF-ACOD-U-0263-HP");

 12363 	}

 12365 /** @xxxx

 12366  * PCM16 to IMAS Test for memory scribbles

 12367  * @test Req. under test REQ172.11

 12368  */

 12369 TVerdict CTest_MMF_ACOD_U_0263::DoTestStepL()

 12370 	{

 12371 	const TUid codecUid = {KMmfUidCodecPCM16ToIMAADPCMStereo};

 12372 	TBool testOK = EFalse;

 12373 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 12375 	if (err)

 12376 		{

 12377 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12378 		return EFail;

 12379 		}

 12380 	else if (!testOK)

 12381 		{

 12382 		INFO_PRINTF1(_L("Test failed"));

 12383 		return EFail;

 12384 		}

 12385 	else

 12386 		return EPass;

 12387 	}

 12389 //------------------------------------------------------------------

 12391 /** @xxxx

 12392  * Constructor

 12393  */

 12394 CTest_MMF_ACOD_U_0264::CTest_MMF_ACOD_U_0264()

 12395 	{

 12396 	// store the name of this test case

 12397 	// this is the name that is used by the script file

 12398 	// Each test step initialises it's own name

 12399 	iTestStepName = _L("MM-MMF-ACOD-U-0264-HP");

 12401 	for (TUint i=0; i<5; i++)

 12402 		{

 12403 		iExpectedSrcBytesProcessed[i] = 0;

 12404 		iExpectedDstBytesAdded[i] = 0;

 12405 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 12406 		}

 12407 	}

 12409 /** @xxxx

 12410  * GSM610 To PCM16 Pass in zero sized source buffer

 12411  * @test Req. under test REQ172.6.4, REQ172.6.5

 12412  */

 12413 TVerdict CTest_MMF_ACOD_U_0264::DoTestStepL()

 12414 	{

 12415 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

 12416 	TBool testOK = EFalse;

 12417 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KGSM610ToPCM16OptimumDst));

 12419 	if (err)

 12420 		{

 12421 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12422 		return EFail;

 12423 		}

 12424 	else if (!testOK)

 12425 		{

 12426 		INFO_PRINTF1(_L("Test failed"));

 12427 		return EFail;

 12428 		}

 12429 	else

 12430 		return EPass;

 12431 	}

 12433 //------------------------------------------------------------------

 12435 /** @xxxx

 12436  * Constructor

 12437  */

 12438 CTest_MMF_ACOD_U_0265::CTest_MMF_ACOD_U_0265()

 12439 	{

 12440 	// store the name of this test case

 12441 	// this is the name that is used by the script file

 12442 	// Each test step initialises it's own name

 12443 	iTestStepName = _L("MM-MMF-ACOD-U-0265-HP");

 12445 	iExpectedLeaveErrorCode = KErrArgument;

 12446 	}

 12448 /** @xxxx

 12449  * GSM610 To PCM16 Pass in zero sized destination buffer

 12450  * @test Req. under test REQ172.6.4, REQ172.6.5

 12451  */

 12452 TVerdict CTest_MMF_ACOD_U_0265::DoTestStepL()

 12453 	{

 12454 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

 12455 	TBool testOK = EFalse;

 12456 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KGSM610ToPCM16OptimumSrc, 0));

 12458 	if (err)

 12459 		{

 12460 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12461 		return EFail;

 12462 		}

 12463 	else if (!testOK)

 12464 		{

 12465 		INFO_PRINTF1(_L("Test failed"));

 12466 		return EFail;

 12467 		}

 12468 	else

 12469 		return EPass;

 12470 	}

 12472 //------------------------------------------------------------------

 12474 /** @xxxx

 12475  * Constructor

 12476  */

 12477 CTest_MMF_ACOD_U_0266::CTest_MMF_ACOD_U_0266()

 12478 	{

 12479 	// store the name of this test case

 12480 	// this is the name that is used by the script file

 12481 	// Each test step initialises it's own name

 12482 	iTestStepName = _L("MM-MMF-ACOD-U-0266-HP");

 12483 	}

 12485 /** @xxxx

 12486  * GSM610 To PCM16 Test out of memory

 12487  * @test Req. under test REQ172.11

 12488  */

 12489 TVerdict CTest_MMF_ACOD_U_0266::DoTestStepL()

 12490 	{

 12491 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

 12492 	TBool testOK = EFalse;

 12494 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 12495 	if (err==KErrNone && testOK)

 12496 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 12498 	if (err)

 12499 		{

 12500 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12501 		return EFail;

 12502 		}

 12503 	else if (!testOK)

 12504 		{

 12505 		INFO_PRINTF1(_L("Test failed"));

 12506 		return EFail;

 12507 		}

 12508 	else

 12509 		return EPass;

 12510 	}

 12512 //------------------------------------------------------------------

 12514 /** @xxxx

 12515  * Constructor

 12516  */

 12517 CTest_MMF_ACOD_U_0267::CTest_MMF_ACOD_U_0267()

 12518 	{

 12519 	// store the name of this test case

 12520 	// this is the name that is used by the script file

 12521 	// Each test step initialises it's own name

 12522 	iTestStepName = _L("MM-MMF-ACOD-U-0267-HP");

 12523 	}

 12525 /** @xxxx

 12526  * GSM610 To PCM16 Test for memory leaks

 12527  * @test Req. under test REQ172.11

 12528  */

 12529 TVerdict CTest_MMF_ACOD_U_0267::DoTestStepL()

 12530 	{

 12531 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

 12532 	TBool testOK = EFalse;

 12533 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 12535 	if (err)

 12536 		{

 12537 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12538 		return EFail;

 12539 		}

 12540 	else if (!testOK)

 12541 		{

 12542 		INFO_PRINTF1(_L("Test failed"));

 12543 		return EFail;

 12544 		}

 12545 	else

 12546 		return EPass;

 12547 	}

 12549 //------------------------------------------------------------------

 12551 /** @xxxx

 12552  * Constructor

 12553  */

 12554 CTest_MMF_ACOD_U_0268::CTest_MMF_ACOD_U_0268()

 12555 	{

 12556 	// store the name of this test case

 12557 	// this is the name that is used by the script file

 12558 	// Each test step initialises it's own name

 12559 	iTestStepName = _L("MM-MMF-ACOD-U-0268-HP");

 12560 	}

 12562 /** @xxxx

 12563  * GSM610 To PCM16 Test for memory scribbles

 12564  * @test Req. under test REQ172.11

 12565  */

 12566 TVerdict CTest_MMF_ACOD_U_0268::DoTestStepL()

 12567 	{

 12568 	const TUid codecUid = {KMmfUidCodecGSM610ToPCM16};

 12569 	TBool testOK = EFalse;

 12570 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 12572 	if (err)

 12573 		{

 12574 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12575 		return EFail;

 12576 		}

 12577 	else if (!testOK)

 12578 		{

 12579 		INFO_PRINTF1(_L("Test failed"));

 12580 		return EFail;

 12581 		}

 12582 	else

 12583 		return EPass;

 12584 	}

 12586 //------------------------------------------------------------------

 12588 /** @xxxx

 12589  * Constructor

 12590  */

 12591 CTest_MMF_ACOD_U_0269::CTest_MMF_ACOD_U_0269()

 12592 	{

 12593 	// store the name of this test case

 12594 	// this is the name that is used by the script file

 12595 	// Each test step initialises it's own name

 12596 	iTestStepName = _L("MM-MMF-ACOD-U-0269-HP");

 12598 	for (TUint i=0; i<5; i++)

 12599 		{

 12600 		iExpectedSrcBytesProcessed[i] = 0;

 12601 		iExpectedDstBytesAdded[i] = 0;

 12602 		iExpectedReturnValue[i].iStatus = TCodecProcessResult::EDstNotFilled;

 12603 		}

 12604 	}

 12606 /** @xxxx

 12607  * PCM16 to GSM610 Pass in zero sized source buffer

 12608  * @test Req. under test REQ172.6.4, REQ172.6.5

 12609  */

 12610 TVerdict CTest_MMF_ACOD_U_0269::DoTestStepL()

 12611 	{

 12612 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

 12613 	TBool testOK = EFalse;

 12614 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, 0, KPCM16ToGSM610OptimumDst));

 12616 	if (err)

 12617 		{

 12618 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12619 		return EFail;

 12620 		}

 12621 	else if (!testOK)

 12622 		{

 12623 		INFO_PRINTF1(_L("Test failed"));

 12624 		return EFail;

 12625 		}

 12626 	else

 12627 		return EPass;

 12628 	}

 12630 //------------------------------------------------------------------

 12632 /** @xxxx

 12633  * Constructor

 12634  */

 12635 CTest_MMF_ACOD_U_0270::CTest_MMF_ACOD_U_0270()

 12636 	{

 12637 	// store the name of this test case

 12638 	// this is the name that is used by the script file

 12639 	// Each test step initialises it's own name

 12640 	iTestStepName = _L("MM-MMF-ACOD-U-0270-HP");

 12642 	iExpectedLeaveErrorCode = KErrArgument;

 12643 	}

 12645 /** @xxxx

 12646  * PCM16 to GSM610 Pass in zero sized destination buffer

 12647  * @test Req. under test REQ172.6.4, REQ172.6.5

 12648  */

 12649 TVerdict CTest_MMF_ACOD_U_0270::DoTestStepL()

 12650 	{

 12651 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

 12652 	TBool testOK = EFalse;

 12653 	TRAPD(err, testOK = TestProcessLLoopFiveTimesL(codecUid, KPCM16ToGSM610OptimumSrc, 0));

 12655 	if (err)

 12656 		{

 12657 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12658 		return EFail;

 12659 		}

 12660 	else if (!testOK)

 12661 		{

 12662 		INFO_PRINTF1(_L("Test failed"));

 12663 		return EFail;

 12664 		}

 12665 	else

 12666 		return EPass;

 12667 	}

 12669 //------------------------------------------------------------------

 12671 /** @xxxx

 12672  * Constructor

 12673  */

 12674 CTest_MMF_ACOD_U_0271::CTest_MMF_ACOD_U_0271()

 12675 	{

 12676 	// store the name of this test case

 12677 	// this is the name that is used by the script file

 12678 	// Each test step initialises it's own name

 12679 	iTestStepName = _L("MM-MMF-ACOD-U-0271-HP");

 12680 	}

 12682 /** @xxxx

 12683  * PCM16 to GSM610 Test out of memory

 12684  * @test Req. under test REQ172.11

 12685  */

 12686 TVerdict CTest_MMF_ACOD_U_0271::DoTestStepL()

 12687 	{

 12688 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

 12689 	TBool testOK = EFalse;

 12691 	TRAPD(err, testOK = TestNewLOutOfMemoryL(codecUid));

 12692 	if (err==KErrNone && testOK)

 12693 		TRAP(err, testOK = TestProcessLOutOfMemoryL(codecUid));

 12695 	if (err)

 12696 		{

 12697 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12698 		return EFail;

 12699 		}

 12700 	else if (!testOK)

 12701 		{

 12702 		INFO_PRINTF1(_L("Test failed"));

 12703 		return EFail;

 12704 		}

 12705 	else

 12706 		return EPass;

 12707 	}

 12709 //------------------------------------------------------------------

 12712 /** @xxxx

 12713  * Constructor

 12714  */

 12715 CTest_MMF_ACOD_U_0272::CTest_MMF_ACOD_U_0272()

 12716 	{

 12717 	// store the name of this test case

 12718 	// this is the name that is used by the script file

 12719 	// Each test step initialises it's own name

 12720 	iTestStepName = _L("MM-MMF-ACOD-U-0272-HP");

 12721 	}

 12723 /** @xxxx

 12724  * PCM16 to GSM610 Test for memory leaks

 12725  * @test Req. under test REQ172.11

 12726  */

 12727 TVerdict CTest_MMF_ACOD_U_0272::DoTestStepL()

 12728 	{

 12729 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

 12730 	TBool testOK = EFalse;

 12731 	TRAPD(err, testOK = TestMemoryLeakL(codecUid));

 12733 	if (err)

 12734 		{

 12735 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12736 		return EFail;

 12737 		}

 12738 	else if (!testOK)

 12739 		{

 12740 		INFO_PRINTF1(_L("Test failed"));

 12741 		return EFail;

 12742 		}

 12743 	else

 12744 		return EPass;

 12745 	}

 12747 //------------------------------------------------------------------

 12749 /** @xxxx

 12750  * Constructor

 12751  */

 12752 CTest_MMF_ACOD_U_0273::CTest_MMF_ACOD_U_0273()

 12753 	{

 12754 	// store the name of this test case

 12755 	// this is the name that is used by the script file

 12756 	// Each test step initialises it's own name

 12757 	iTestStepName = _L("MM-MMF-ACOD-U-0273-HP");

 12758 	}

 12760 /** @xxxx

 12761  * PCM16 to GSM610 Test for memory scribbles

 12762  * @test Req. under test REQ172.11

 12763  */

 12764 TVerdict CTest_MMF_ACOD_U_0273::DoTestStepL()

 12765 	{

 12766 	const TUid codecUid = {KMmfUidCodecPCM16ToGSM610};

 12767 	TBool testOK = EFalse;

 12768 	TRAPD(err, testOK = TestMemoryScribbleL(codecUid));

 12770 	if (err)

 12771 		{

 12772 		INFO_PRINTF2(_L("Test left with status %d"), err);

 12773 		return EFail;

 12774 		}

 12775 	else if (!testOK)

 12776 		{

 12777 		INFO_PRINTF1(_L("Test failed"));

 12778 		return EFail;

 12779 		}

 12780 	else

 12781 		return EPass;

 12782 	}

 12784 //------------------------------------------------------------------

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--