Symaptic: os/mm/mmlibs/mmfw/tsrc/mmfunittest/ctlfrm/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 // NB: these includes are added here to pull in includes from MmfControllerFramework.h

    15 // They are placed here as we are messing aroung with private (see below) to allow access to

    16 // the private member iSubThread in RMMFControllerProxy for test 152 without resorting to friend

    17 // classes. This was done to test INC038123.

    18 // +++++++++  Start of playing around with private block. +++++++++++++

    19 //

    20 //

    22 #include <e32base.h>

    23 #include <e32std.h>

    24 #include <mmf/common/mmfutilities.h>

    25 #include <mmf/common/mmfcontrollerframeworkbase.h>

    27 #define private public

    28 #include <mmf/common/mmfcontrollerframework.h>

    29 #undef private

    30 //++++++++ End of playing around with private block. +++++++++++

    33 // Test system includes

    34 #include <testframework.h>

    36 #include <mmf/plugin/mmfformatimplementationuids.hrh>

    37 #include <mmf/plugin/mmfcontrollerimplementationuids.hrh>

    39 #include "CmmfTestControllerUIDs.hrh"

    40 #include "cmmftestterminationcontrolleruids.hrh"

    41 #include "TSU_MMF_CTLFRM.h"

    42 #include "TSU_MMF_CTLFRMSuite.h"

    44 //const TUid KMmfUidControllerAudioUid = {KMmfUidControllerAudio};	// EABI warning removal

    45 const TUid KTstControllerUid = {KMmfTestControllerUid}; //(0x101F88D8)

    46 const TUid KTestDataSourceUid = {KMmfTestDataSourceUid};

    47 const TUid KTestDataSourceBUid = {KMmfTestDataSourceBUid};

    48 const TUid KTestDataSinkUid = {KMmfTestDataSinkUid};

    49 const TUid KTestDataSinkBUid = 	{KMmfTestDataSinkBUid};

    50 const TUid KTestTerminationControllerUid = {KMmfTestTerminationControllerUid};

    52 // Expected results in Test 0140s.

    53 // 'KMmfUidControllerAudio' is the preferred Controller used in these tests

    54 const TUid KExpectedMediaIDUid140 = {0x101F7D8D};//{0x101F5D07};

    56 const TUid KMmfUidFormatPAVReadUid = {KMmfUidFormatPAVRead};

    57 const TUid KMmfUidFormatFAWReadUid = {KMmfUidFormatFAWRead};

    58 const TUid KMmfUidFormatAIReadUid = {KMmfUidFormatAIRead};

    59 const TUid KMmfUidFormatMBEGReadUid = {KMmfUidFormatMBEGRead};

    61 const TUid KMmfUidFormatPAVWriteUid = {KMmfUidFormatPAVWrite};

    62 const TUid KMmfUidFormatFAWWriteUid = {KMmfUidFormatFAWWrite};

    63 const TUid KMmfUidFormatAIWriteUid = {KMmfUidFormatAIWrite};

    65 const TUid KMmfUidPluginInterfaceFormatEncodeUid = {KMmfUidPluginInterfaceFormatEncode};

    66 const TUid KMmfUidPluginInterfaceFormatDecodeUid = {KMmfUidPluginInterfaceFormatDecode};

    68 _LIT(KTestControllerSupplier, "TSU_MMF_CTLFRM");

    70 // Used as dummy data to pass to sources, sinks etc

    71 _LIT8(KInitData,"TEST");

    73 /**

    74  *

    75  * CTestStepSelfTest constructor

    76  *

    77  * @xxxx

    78  *

    79  */

    80 CTestStep_MMF_CTLFRM::CTestStep_MMF_CTLFRM()

    81 	{

    82 	}

    84 /**

    85  *

    86  * CTestStepSelfTest destructor

    87  *

    88  * @xxxx

    89  *

    90  */

    91 CTestStep_MMF_CTLFRM::~CTestStep_MMF_CTLFRM()

    92 	{

    93 	}

    95 TVerdict CTestStep_MMF_CTLFRM::DoTestStepPreambleL()

    96 	{

    97 	TVerdict verdict = EPass;

    99 	return verdict;

   100 	}

   102 TVerdict CTestStep_MMF_CTLFRM::DoTestStepPostambleL()

   103 	{

   104 	TVerdict verdict = EPass;

   106 	return verdict;

   107 	}

   110 CTestStep_MMF_CTLFRM_U_0001::CTestStep_MMF_CTLFRM_U_0001()

   111 	/** Constructor

   112 	*/

   113 	{

   114 	// store the name of this test case

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

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

   117 	iTestStepName = _L("MM-MMF-CTLFRM-U-0001");

   120 	}

   123 TVerdict CTestStep_MMF_CTLFRM_U_0001::DoTestStepL( void )

   124 /**

   125  * Call the RMMFController::Open(..) with the parameters specified,

   126  * varify the return value is 0. Call the RMMFController::Close() on the Custom Controller.

   127  * Varify 'error' is 0.

   129  * Use case: N/A

   130  * @test Req. under test REQ172.5.1 REQ172.5.2 REQ172.5.5.12

   131  */

   132 	{

   133 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   134 	__MM_HEAP_MARK;

   136 	TVerdict verdict = EPass;

   138 	TMMFPrioritySettings settings;

   139 	TInt error = KErrNone;

   140 	RMMFController controller;

   142 	settings.iPriority = 1;

   143 	settings.iPref = EMdaPriorityPreferenceTime;

   144 	settings.iState = EMMFStateIdle;

   146 	INFO_PRINTF1(_L("Attempting to Open Controller"));

   148 	// Open a Custom Controller

   149 	error = controller.Open(KTstControllerUid,settings);

   150 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   152 	if (error)

   153 		{

   154 		verdict = EFail;

   155 		}

   157 	INFO_PRINTF1(_L("Closing Controller"));

   158 	controller.Close();

   160 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

   161 	__MM_HEAP_MARKEND;

   163 	return verdict;

   164 	}

   167 //------------------------------------------------------------------

   170 CTestStep_MMF_CTLFRM_U_0007::CTestStep_MMF_CTLFRM_U_0007()

   171 	/** Constructor

   172 	*/

   173 	{

   174 	// store the name of this test case

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

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

   177 	iTestStepName = _L("MM-MMF-CTLFRM-U-0007");

   180 	}

   183 TVerdict CTestStep_MMF_CTLFRM_U_0007::DoTestStepL( void )

   184 /** Call the RMMFController::Open(..) (with the parameters from test TSU_MMF_CTLFRM_U_0001),

   185  *  varify the return value is 0. Instantiate a Custom DataSource Object and add  it to

   186  *  the Custom Controller using RMMFController::AddDataSource(..), with the specified

   187  *  parameters. Call Custom Command 'KLogFunction' and varify the text value returned is

   188  *  equal to the specifed text in Test Step. Call the RMMFController::Close() on the Custom

   189  *  Controller. Varify 'error' is 0.

   191  * Use case: N/A

   192  * @test Req. under test REQ172.5.5 REQ172.5.5.1

   193  */

   194 	{

   195 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   196 	__MM_HEAP_MARK;

   198 	TVerdict verdict = EPass;

   199 	_LIT8(KExpectedResult, "AddDataSourceL Called");

   201 	TMMFPrioritySettings settings;

   202 	TInt error = KErrNone;

   203 	RMMFController controller;

   205 	settings.iPriority = 1;

   206 	settings.iPref = EMdaPriorityPreferenceTime;

   207 	settings.iState = EMMFStateIdle;

   209 	error = controller.Open(KTstControllerUid,settings);

   210 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   212 	const TDesC8& initData = KInitData;

   214 	// Add Source

   215 	INFO_PRINTF1(_L("Attempting to add a Source and a Sink to Controller"));

   216 	if (!error)

   217 		{

   218 		INFO_PRINTF1(_L("API TEST: Calling AddDataSource"));

   219 		error = controller.AddDataSource(KTestDataSourceUid, initData);

   220 		error = controller.AddDataSource(KTestDataSourceBUid, initData);

   221 		}

   223 	INFO_PRINTF2(_L("Controller Status: %d"), error);

   225 	//------------------------------------//

   226 	// Getting Log from Custom Controller //

   227 	//------------------------------------//

   228 	if (!error)

   229 		{

   230 		INFO_PRINTF1(_L("Getting Log"));

   232 		TBuf8<64> memFunctionText;

   234 		TUid uid = {KMmfTestControllerUid};

   235 		TMMFMessageDestination handleInfo(uid);

   236 		TMMFMessageDestinationPckg messageDest(handleInfo);

   238 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

   240 		TBuf<64> memFunctionText16;

   241 		memFunctionText16.Copy(memFunctionText);

   242 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

   245 		if (memFunctionText != KExpectedResult)

   246 			{

   247 			verdict = EFail;

   248 			}

   250 		}

   251 	//------------------------------------//

   254 	INFO_PRINTF1(_L("Closing Controller"));

   255 	controller.Close();

   257 	if (error)

   258 		{

   259 		verdict = EFail;

   260 		}

   262 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

   263 	__MM_HEAP_MARKEND;

   265 	return verdict;

   266 	}

   268 //------------------------------------------------------------------

   270 CTestStep_MMF_CTLFRM_U_0008::CTestStep_MMF_CTLFRM_U_0008()

   271 	/** Constructor

   272 	*/

   273 	{

   274 	// store the name of this test case

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

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

   277 	iTestStepName = _L("MM-MMF-CTLFRM-U-0008");

   280 	}

   282 TVerdict CTestStep_MMF_CTLFRM_U_0008::DoTestStepL( void )

   283 /** Call the RMMFController::Open(..) (with the parameters from test TSU_MMF_CTLFRM_U_0001),

   284  *  varify the return value is 0. Instantiate a Custom DataSink Object and add it to the

   285  *  Custom Controller using RMMFController::AddDataSink(..), with the specified parameters.

   286  *  Call Custom Command 'KLogFunction' and varify the text value returned is equal to the

   287  *  specifed text in Test Step. Call the RMMFController::Close() on the Custom Controller.

   288  *  Varify 'error' is 0.

   290  * Use case: N/A

   291  * @test Req. under test REQ172.5.5 REQ172.5.5.3

   292  */

   293 	{

   294 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   295 	__MM_HEAP_MARK;

   297 	TVerdict verdict = EPass;

   298 	_LIT8(KExpectedResult, "AddDataSinkL Called");

   300 	TMMFPrioritySettings settings;

   301 	TInt error = KErrNone;

   302 	RMMFController controller;

   304 	settings.iPriority = 1;

   305 	settings.iPref = EMdaPriorityPreferenceTime;

   306 	settings.iState = EMMFStateIdle;

   308 	error = controller.Open(KTstControllerUid,settings);

   309 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   311 	const TDesC8& initData = KInitData;

   313 	// Add Sink

   314 	if (!error)

   315 		{

   316 		INFO_PRINTF1(_L("API TEST: Calling AddDataSink"));

   317 		error = controller.AddDataSink(KTestDataSinkUid, initData);

   318 		error = controller.AddDataSink(KTestDataSinkBUid, initData);

   319 		}

   322 	INFO_PRINTF2(_L("Controller Status: %d"), error);

   324 	//------------------------------------//

   325 	// Getting Log from Custom Controller //

   326 	//------------------------------------//

   327 	if (!error)

   328 		{

   329 		INFO_PRINTF1(_L("Getting Log"));

   331 		TBuf8<64> memFunctionText;

   333 		TUid uid = {KMmfTestControllerUid};

   334 		TMMFMessageDestination handleInfo(uid);

   335 		TMMFMessageDestinationPckg messageDest(handleInfo);

   337 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

   339 		TBuf<64> memFunctionText16;

   340 		memFunctionText16.Copy(memFunctionText);

   341 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

   343 		if (memFunctionText != KExpectedResult)

   344 			{

   345 			verdict = EFail;

   346 			}

   348 		}

   349 	//------------------------------------//

   351 	INFO_PRINTF1(_L("Closing Controller"));

   352 	controller.Close();

   354 	if (error)

   355 		{

   356 		verdict = EFail;

   357 		}

   359 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

   360 	__MM_HEAP_MARKEND;

   362 	return verdict;

   363 	}

   365 //------------------------------------------------------------------

   367 CTestStep_MMF_CTLFRM_U_0009::CTestStep_MMF_CTLFRM_U_0009()

   368 	/** Constructor

   369 	*/

   370 	{

   371 	// store the name of this test case

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

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

   374 	iTestStepName = _L("MM-MMF-CTLFRM-U-0009");

   377 	}

   379 TVerdict CTestStep_MMF_CTLFRM_U_0009::DoTestStepL( void )

   380 /** Call the RMMFController::Open(..) (with the parameters from test TSU_MMF_CTLFRM_U_0001),

   381  *  varify the return value is 0. Instantiate a Custom DataSource Object and add it to the

   382  *  Custom Controller using RMMFController::AddDataSource(..), with the specified parameters.

   383  *  Call Custom Command 'KLogFunction' and varify the text value returned is equal to the

   384  *  specifed text in Test Step. Call the RMMFController::Close() on the Custom Controller.

   385  *  Varify 'error' is 0.

   387  * Use case: N/A

   388  * @test Req. under test REQ172.5.5 REQ172.5.5.1

   389  */

   390 	{

   391 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   392 	__MM_HEAP_MARK;

   394 	TVerdict verdict = EPass;

   395 	_LIT8(KExpectedResult, "AddDataSourceL Called");

   397 	TMMFPrioritySettings settings;

   398 	TInt error = KErrNone;

   399 	RMMFController controller;

   401 	settings.iPriority = 1;

   402 	settings.iPref = EMdaPriorityPreferenceTime;

   403 	settings.iState = EMMFStateIdle;

   405 	error = controller.Open(KTstControllerUid,settings);

   406 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   408 	const TDesC8& initData = KInitData;

   410 	TMMFMessageDestination sourceHandlePtr;

   411 	TMMFMessageDestination& sourceHandle = sourceHandlePtr;

   413 	// Add Source

   414 	INFO_PRINTF1(_L("Attempting to add a Source and a Sink to Controller"));

   415 	if (!error)

   416 		{

   417 		INFO_PRINTF1(_L("API TEST: Calling AddDataSource"));

   418 		error = controller.AddDataSource(KTestDataSourceUid, initData, sourceHandle);

   419 		}

   421 	INFO_PRINTF2(_L("Controller Status: %d"), error);

   423 	//------------------------------------//

   424 	// Getting Log from Custom Controller //

   425 	//------------------------------------//

   426 	if (!error)

   427 		{

   428 		INFO_PRINTF1(_L("Getting Log"));

   430 		TBuf8<64> memFunctionText;

   432 		TUid uid = {KMmfTestControllerUid};

   433 		TMMFMessageDestination handleInfo(uid);

   434 		TMMFMessageDestinationPckg messageDest(handleInfo);

   436 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

   438 		TBuf<64> memFunctionText16;

   439 		memFunctionText16.Copy(memFunctionText);

   440 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

   442 		if (memFunctionText != KExpectedResult)

   443 			{

   444 			verdict = EFail;

   445 			}

   447 		}

   448 	//------------------------------------//

   450 	INFO_PRINTF1(_L("Closing Controller"));

   451 	controller.Close();

   453 	if (error)

   454 		{

   455 		verdict = EFail;

   456 		}

   458 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

   459 	__MM_HEAP_MARKEND;

   461 	return verdict;

   462 	}

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

   466 CTestStep_MMF_CTLFRM_U_0010::CTestStep_MMF_CTLFRM_U_0010()

   467 	/** Constructor

   468 	*/

   469 	{

   470 	// store the name of this test case

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

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

   473 	iTestStepName = _L("MM-MMF-CTLFRM-U-0010");

   476 	}

   478 TVerdict CTestStep_MMF_CTLFRM_U_0010::DoTestStepL( void )

   479 /** Call the RMMFController::Open(..) (with the parameters from test TSU_MMF_CTLFRM_U_0001),

   480  *  varify the return value is 0. Instantiate a Custom DataSink Object and add it to the

   481  *  Custom Controller using RMMFController::AddDataSink(..), with the specified parameters.

   482  *  Call Custom Command 'KLogFunction' and varify the text value returned is equal to the

   483  *  specifed text in Test Step. Call the RMMFController::Close() on the Custom Controller.

   484  *  Varify 'error' is 0.

   486  * Use case: N/A

   487  * @test Req. under test REQ172.5.5 REQ172.5.5.3

   488  */

   489 	{

   490 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   491 	__MM_HEAP_MARK;

   493 	TVerdict verdict = EPass;

   494 	_LIT8(KExpectedResult, "AddDataSinkL Called");

   496 	TMMFPrioritySettings settings;

   497 	TInt error = KErrNone;

   498 	RMMFController controller;

   500 	settings.iPriority = 1;

   501 	settings.iPref = EMdaPriorityPreferenceTime;

   502 	settings.iState = EMMFStateIdle;

   504 	error = controller.Open(KTstControllerUid,settings);

   505 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   507 	const TDesC8& initData = KInitData;

   508 	TMMFMessageDestination sinkHandlePtr;

   509 	TMMFMessageDestination& sinkHandle = sinkHandlePtr;

   511 	// Add Sink

   512 	if (!error)

   513 		{

   514 		INFO_PRINTF1(_L("API TEST: Calling AddDataSink"));

   515 		error = controller.AddDataSink(KTestDataSinkUid, initData, sinkHandle);

   516 		}

   518 	INFO_PRINTF2(_L("Controller Status: %d"), error);

   520 	//------------------------------------//

   521 	// Getting Log from Custom Controller //

   522 	//------------------------------------//

   523 	if (!error)

   524 		{

   525 		INFO_PRINTF1(_L("Getting Log"));

   527 		TBuf8<64> memFunctionText;

   529 		TUid uid = {KMmfTestControllerUid};

   530 		TMMFMessageDestination handleInfo(uid);

   531 		TMMFMessageDestinationPckg messageDest(handleInfo);

   533 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

   535 		TBuf<64> memFunctionText16;

   536 		memFunctionText16.Copy(memFunctionText);

   537 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

   539 		if (memFunctionText != KExpectedResult)

   540 			{

   541 			verdict = EFail;

   542 			}

   544 		}

   545 	//------------------------------------//

   547 	INFO_PRINTF1(_L("Closing Controller"));

   548 	controller.Close();

   550 	if (error)

   551 		{

   552 		verdict = EFail;

   553 		}

   555 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

   556 	__MM_HEAP_MARKEND;

   558 	return verdict;

   559 	}

   562 //------------------------------------------------------------------

   564 CTestStep_MMF_CTLFRM_U_0011::CTestStep_MMF_CTLFRM_U_0011()

   565 	/** Constructor

   566 	*/

   567 	{

   568 	// store the name of this test case

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

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

   571 	iTestStepName = _L("MM-MMF-CTLFRM-U-0011");

   574 	}

   576 TVerdict CTestStep_MMF_CTLFRM_U_0011::DoTestStepL( void )

   577 /** Call the RMMFController::Open(..) (with the parameters from test TSU_MMF_CTLFRM_U_0001),

   578  *  varify the return value is 0. Instantiate a Custom DataSource Object and add it to the

   579  *  Custom Controller using RMMFController::AddDataSource(..), with the specified parameters.

   580  *  Call Custom Command 'KLogFunction' and varify the text value returned is equal to the

   581  *  specifed text in Test Step. Call the RMMFController::Close() on the Custom Controller.

   582  *  Varify 'error' is 0.

   584  * Use case: N/A

   585  * @test Req. under test REQ172.5.5 REQ172.5.5.2

   586  */

   587 	{

   588 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   589 	__MM_HEAP_MARK;

   591 	TVerdict verdict = EPass;

   592 	_LIT8(KExpectedResult,"RemoveDataSourceL Called");

   594 	TMMFPrioritySettings settings;

   595 	TInt error = KErrNone;

   596 	RMMFController controller;

   598 	settings.iPriority = 1;

   599 	settings.iPref = EMdaPriorityPreferenceTime;

   600 	settings.iState = EMMFStateIdle;

   602 	error = controller.Open(KTstControllerUid,settings);

   603 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   605 	const TDesC8& initData = KInitData;

   607 	TMMFMessageDestination sourceHandlePtr;

   608 	TMMFMessageDestination& sourceHandle = sourceHandlePtr;

   610 	// Add and Remove Source

   611 	INFO_PRINTF1(_L("Attempting to add a Source and a Sink to Controller"));

   612 	if (!error)

   613 		{

   614 		error = controller.AddDataSource(KTestDataSourceUid, initData, sourceHandle);

   615 		INFO_PRINTF1(_L("API TEST: Calling RemoveDataSource"));

   616 		error = controller.RemoveDataSource(sourceHandle);

   617 		}

   619 	INFO_PRINTF2(_L("Controller Status: %d"), error);

   621 		//------------------------------------//

   622 	// Getting Log from Custom Controller //

   623 	//------------------------------------//

   624 	if (!error)

   625 		{

   626 		INFO_PRINTF1(_L("Getting Log"));

   628 		TBuf8<64> memFunctionText;

   630 		TUid uid = {KMmfTestControllerUid};

   631 		TMMFMessageDestination handleInfo(uid);

   632 		TMMFMessageDestinationPckg messageDest(handleInfo);

   634 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

   636 		TBuf<64> memFunctionText16;

   637 		memFunctionText16.Copy(memFunctionText);

   638 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

   640 		if (memFunctionText != KExpectedResult)

   641 			{

   642 			verdict = EFail;

   643 			}

   645 		}

   646 	//------------------------------------//

   648 	INFO_PRINTF1(_L("Closing Controller"));

   649 	controller.Close();

   651 	if (error)

   652 		{

   653 		verdict = EFail;

   654 		}

   656 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

   657 	__MM_HEAP_MARKEND;

   659 	return verdict;

   660 	}

   663 //------------------------------------------------------------------

   665 CTestStep_MMF_CTLFRM_U_0012::CTestStep_MMF_CTLFRM_U_0012()

   666 	/** Constructor

   667 	*/

   668 	{

   669 	// store the name of this test case

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

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

   672 	iTestStepName = _L("MM-MMF-CTLFRM-U-0012");

   675 	}

   677 TVerdict CTestStep_MMF_CTLFRM_U_0012::DoTestStepL( void )

   678 /** Call the RMMFController::Open(..) (with the parameters from test TSU_MMF_CTLFRM_U_0001),

   679  *  varify the return value is 0. Instantiate a Custom DataSink Object and add it to the

   680  *  Custom Controller using RMMFController::AddDataSink(..), with the specified parameters.

   681  *  Call Custom Command 'KLogFunction' and varify the text value returned is equal to the

   682  *  specifed text in Test Step. Call the RMMFController::Close() on the Custom Controller.

   683  *  Varify 'error' is 0.

   685  * Use case: N/A

   686  * @test Req. under test REQ172.5.5 REQ172.5.5.4

   687  */

   688 	{

   689 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   690 	__MM_HEAP_MARK;

   692 	TVerdict verdict = EPass;

   693 	_LIT8(KExpectedResult, "RemoveDataSinkL Called");

   695 	TMMFPrioritySettings settings;

   696 	TInt error = KErrNone;

   697 	RMMFController controller;

   699 	settings.iPriority = 1;

   700 	settings.iPref = EMdaPriorityPreferenceTime;

   701 	settings.iState = EMMFStateIdle;

   703 	error = controller.Open(KTstControllerUid,settings);

   704 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   706 	const TDesC8& initData = KInitData;

   707 	TMMFMessageDestination sinkHandlePtr;

   708 	TMMFMessageDestination& sinkHandle = sinkHandlePtr;

   710 	// Add and Remove Sink

   711 	if (!error)

   712 		{

   713 		error = controller.AddDataSink(KTestDataSinkUid, initData, sinkHandle);

   714 		INFO_PRINTF1(_L("API TEST: Calling RemoveDataSink"));

   715 		error = controller.RemoveDataSink(sinkHandle);

   716 		}

   718 	INFO_PRINTF2(_L("Controller Status: %d"), error);

   720 	//------------------------------------//

   721 	// Getting Log from Custom Controller //

   722 	//------------------------------------//

   723 	if (!error)

   724 		{

   725 		INFO_PRINTF1(_L("Getting Log"));

   727 		TBuf8<64> memFunctionText;

   729 		TUid uid = {KMmfTestControllerUid};

   730 		TMMFMessageDestination handleInfo(uid);

   731 		TMMFMessageDestinationPckg messageDest(handleInfo);

   733 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

   735 		TBuf<64> memFunctionText16;

   736 		memFunctionText16.Copy(memFunctionText);

   737 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

   739 		if (memFunctionText != KExpectedResult)

   740 			{

   741 			verdict = EFail;

   742 			}

   744 		}

   745 	//------------------------------------//

   747 	INFO_PRINTF1(_L("Closing Controller"));

   748 	controller.Close();

   750 	if (error)

   751 		{

   752 		verdict = EFail;

   753 		}

   755 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

   756 	__MM_HEAP_MARKEND;

   758 	return verdict;

   759 	}

   762 //------------------------------------------------------------------

   764 CTestStep_MMF_CTLFRM_U_0013::CTestStep_MMF_CTLFRM_U_0013()

   765 	/** Constructor

   766 	*/

   767 	{

   768 	// store the name of this test case

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

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

   771 	iTestStepName = _L("MM-MMF-CTLFRM-U-0013");

   774 	}

   776 TVerdict CTestStep_MMF_CTLFRM_U_0013::DoTestStepL( void )

   777 /** Call the RMMFController::Open(..) (with the parameters from test TSU_MMF_CTLFRM_U_0001),

   778  *  varify the return value is 0. Call RMMFController Method specified (in API Method Calls

   779  *  and Parameters) and varify the 'error' is 0. Follow this by calling the  Custom Command

   780  *  'KLogFunction' and varify the text value returned is equal to the specifed text in

   781  *  Test Step. Call the RMMFController::Close() on the Custom Controller. Varify 'error'

   782  *  is zero.

   784  * Use case: N/A

   785  * @test Req. under test No Requirement Found

   786  */

   787 	{

   788 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   789 	__MM_HEAP_MARK;

   791 	TVerdict verdict = EPass;

   792 	_LIT8(KExpectedResult,"ResetL Called");

   794 	TMMFPrioritySettings settings;

   795 	TInt error = KErrNone;

   796 	RMMFController controller;

   798 	settings.iPriority = 1;

   799 	settings.iPref = EMdaPriorityPreferenceTime;

   800 	settings.iState = EMMFStateIdle;

   802 	error = controller.Open(KTstControllerUid,settings);

   803 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   805 	// Reset Controller (API being tested)

   806 	if (!error)

   807 		{

   808 		INFO_PRINTF1(_L("API TEST: Calling Reset"));

   809 		error = controller.Reset();

   810 		}

   812 	INFO_PRINTF2(_L("Controller Status: %d"), error);

   814 	//------------------------------------//

   815 	// Getting Log from Custom Controller //

   816 	//------------------------------------//

   817 	if (!error)

   818 		{

   819 		INFO_PRINTF1(_L("Getting Log"));

   821 		TBuf8<64> memFunctionText;

   823 		TUid uid = {KMmfTestControllerUid};

   824 		TMMFMessageDestination handleInfo(uid);

   825 		TMMFMessageDestinationPckg messageDest(handleInfo);

   827 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

   829 		TBuf<64> memFunctionText16;

   830 		memFunctionText16.Copy(memFunctionText);

   831 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

   833 		if (memFunctionText != KExpectedResult)

   834 			{

   835 			verdict = EFail;

   836 			}

   838 		}

   839 	//------------------------------------//

   841 	INFO_PRINTF1(_L("Closing Controller"));

   842 	controller.Close();

   844 	if (error)

   845 		{

   846 		verdict = EFail;

   847 		}

   849 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

   850 	__MM_HEAP_MARKEND;

   852 	return verdict;

   853 	}

   856 //------------------------------------------------------------------

   858 CTestStep_MMF_CTLFRM_U_0014::CTestStep_MMF_CTLFRM_U_0014()

   859 	/** Constructor

   860 	*/

   861 	{

   862 	// store the name of this test case

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

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

   865 	iTestStepName = _L("MM-MMF-CTLFRM-U-0014");

   868 	}

   870 TVerdict CTestStep_MMF_CTLFRM_U_0014::DoTestStepL( void )

   871 /** As TSU_MMF_CTLFRM_U_0013

   872  * ::Prime()

   873  * Use case: N/A

   874  * @test Req. under test REQ172.5.5 REQ172.5.5.5

   875  */

   876 	{

   877 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   878 	__MM_HEAP_MARK;

   880 	TVerdict verdict = EPass;

   881 	_LIT8(KExpectedResult, "PrimeL Called");

   883 	TMMFPrioritySettings settings;

   884 	TInt error = KErrNone;

   885 	RMMFController controller;

   887 	settings.iPriority = 1;

   888 	settings.iPref = EMdaPriorityPreferenceTime;

   889 	settings.iState = EMMFStateIdle;

   891 	error = controller.Open(KTstControllerUid,settings);

   892 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   894 	// Prime Controller

   895 	if (!error)

   896 		{

   897 		INFO_PRINTF1(_L("API TEST: Calling Prime"));

   898 		error = controller.Prime();

   899 		}

   901 	INFO_PRINTF2(_L("Controller Status: %d"), error);

   903 	//------------------------------------//

   904 	// Getting Log from Custom Controller //

   905 	//------------------------------------//

   906 	if (!error)

   907 		{

   908 		INFO_PRINTF1(_L("Getting Log"));

   910 		TBuf8<64> memFunctionText;

   912 		TUid uid = {KMmfTestControllerUid};

   913 		TMMFMessageDestination handleInfo(uid);

   914 		TMMFMessageDestinationPckg messageDest(handleInfo);

   916 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

   918 		TBuf<64> memFunctionText16;

   919 		memFunctionText16.Copy(memFunctionText);

   920 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

   922 		if (memFunctionText != KExpectedResult)

   923 			{

   924 			verdict = EFail;

   925 			}

   927 		}

   928 	//------------------------------------//

   930 	INFO_PRINTF1(_L("Closing Controller"));

   931 	controller.Close();

   933 	if (error)

   934 		{

   935 		verdict = EFail;

   936 		}

   938 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

   939 	__MM_HEAP_MARKEND;

   941 	return verdict;

   942 	}

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

   947 CTestStep_MMF_CTLFRM_U_0015::CTestStep_MMF_CTLFRM_U_0015()

   948 	/** Constructor

   949 	*/

   950 	{

   951 	// store the name of this test case

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

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

   954 	iTestStepName = _L("MM-MMF-CTLFRM-U-0015");

   957 	}

   959 TVerdict CTestStep_MMF_CTLFRM_U_0015::DoTestStepL( void )

   960 /** As TSU_MMF_CTLFRM_U_0013

   961  *  ::Play()

   962  * Use case: N/A

   963  * @test Req. under test REQ172.5.5 REQ172.5.5.6

   964  */

   965 	{

   966 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

   967 	__MM_HEAP_MARK;

   969 	TVerdict verdict = EPass;

   970 	_LIT8(KExpectedResult, "PlayL Called");

   972 	TMMFPrioritySettings settings;

   973 	TInt error = KErrNone;

   974 	RMMFController controller;

   976 	settings.iPriority = 1;

   977 	settings.iPref = EMdaPriorityPreferenceTime;

   978 	settings.iState = EMMFStateIdle;

   980 	error = controller.Open(KTstControllerUid,settings);

   981 	INFO_PRINTF2(_L("Controller Open: %d"), error);

   983 	// Play Controller

   984 	if (!error)

   985 		{

   986 		INFO_PRINTF1(_L("Calling Play"));

   987 		error = controller.Play();

   988 		}

   990 	INFO_PRINTF2(_L("API TEST: Controller Status: %d"), error);

   992 	//------------------------------------//

   993 	// Getting Log from Custom Controller //

   994 	//------------------------------------//

   995 	if (!error)

   996 		{

   997 		INFO_PRINTF1(_L("Getting Log"));

   999 		TBuf8<64> memFunctionText;

  1001 		TUid uid = {KMmfTestControllerUid};

  1002 		TMMFMessageDestination handleInfo(uid);

  1003 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1005 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1007 		TBuf<64> memFunctionText16;

  1008 		memFunctionText16.Copy(memFunctionText);

  1009 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1011 		if (memFunctionText != KExpectedResult)

  1012 			{

  1013 			verdict = EFail;

  1014 			}

  1016 		}

  1017 	//------------------------------------//

  1019 	INFO_PRINTF1(_L("Closing Controller"));

  1020 	controller.Close();

  1022 	if (error)

  1023 		{

  1024 		verdict = EFail;

  1025 		}

  1027 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1028 	__MM_HEAP_MARKEND;

  1030 	return verdict;

  1031 	}

  1034 //------------------------------------------------------------------

  1036 CTestStep_MMF_CTLFRM_U_0016::CTestStep_MMF_CTLFRM_U_0016()

  1037 	/** Constructor

  1038 	*/

  1039 	{

  1040 	// store the name of this test case

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

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

  1043 	iTestStepName = _L("MM-MMF-CTLFRM-U-0016");

  1046 	}

  1048 TVerdict CTestStep_MMF_CTLFRM_U_0016::DoTestStepL( void )

  1049 /** As TSU_MMF_CTLFRM_U_0013

  1050  * ::Pause()

  1051  * Use case: N/A

  1052  * @test Req. under test REQ172.5.5 REQ172.5.5.8

  1053  */

  1054 	{

  1055 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1056 	__MM_HEAP_MARK;

  1058 	TVerdict verdict = EPass;

  1059 	_LIT8(KExpectedResult, "PauseL Called");

  1061 	TMMFPrioritySettings settings;

  1062 	TInt error = KErrNone;

  1063 	RMMFController controller;

  1065 	settings.iPriority = 1;

  1066 	settings.iPref = EMdaPriorityPreferenceTime;

  1067 	settings.iState = EMMFStateIdle;

  1069 	error = controller.Open(KTstControllerUid,settings);

  1070 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1072 	// Pause Controller

  1073 	if (!error)

  1074 		{

  1075 		INFO_PRINTF1(_L("API TEST: Calling Pause"));

  1076 		error = controller.Pause();

  1077 		}

  1079 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  1081 	//------------------------------------//

  1082 	// Getting Log from Custom Controller //

  1083 	//------------------------------------//

  1084 	if (!error)

  1085 		{

  1086 		INFO_PRINTF1(_L("Getting Log"));

  1088 		TBuf8<64> memFunctionText;

  1090 		TUid uid = {KMmfTestControllerUid};

  1091 		TMMFMessageDestination handleInfo(uid);

  1092 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1094 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1096 		TBuf<64> memFunctionText16;

  1097 		memFunctionText16.Copy(memFunctionText);

  1098 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1100 		if (memFunctionText != KExpectedResult)

  1101 			{

  1102 			verdict = EFail;

  1103 			}

  1105 		}

  1106 	//------------------------------------//

  1108 	INFO_PRINTF1(_L("Closing Controller"));

  1109 	controller.Close();

  1111 	if (error)

  1112 		{

  1113 		verdict = EFail;

  1114 		}

  1116 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1117 	__MM_HEAP_MARKEND;

  1119 	return verdict;

  1120 	}

  1123 //------------------------------------------------------------------

  1125 CTestStep_MMF_CTLFRM_U_0017::CTestStep_MMF_CTLFRM_U_0017()

  1126 	/** Constructor

  1127 	*/

  1128 	{

  1129 	// store the name of this test case

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

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

  1132 	iTestStepName = _L("MM-MMF-CTLFRM-U-0017");

  1135 	}

  1137 TVerdict CTestStep_MMF_CTLFRM_U_0017::DoTestStepL( void )

  1138 /** As TSU_MMF_CTLFRM_U_0013

  1139  * ::Stop()

  1140  * Use case: N/A

  1141  * @test Req. under test REQ172.5.5 REQ172.5.5.7

  1142  */

  1143 	{

  1144 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1145 	__MM_HEAP_MARK;

  1147 	TVerdict verdict = EPass;

  1148 	_LIT8(KExpectedResult, "StopL Called");

  1150 	TMMFPrioritySettings settings;

  1151 	TInt error = KErrNone;

  1152 	RMMFController controller;

  1154 	settings.iPriority = 1;

  1155 	settings.iPref = EMdaPriorityPreferenceTime;

  1156 	settings.iState = EMMFStateIdle;

  1158 	error = controller.Open(KTstControllerUid,settings);

  1159 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1161 	// Stop Controller

  1162 	if (!error)

  1163 		{

  1164 		INFO_PRINTF1(_L("API TEST: Calling Stop"));

  1165 		error = controller.Stop();

  1166 		}

  1168 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  1170 	//------------------------------------//

  1171 	// Getting Log from Custom Controller //

  1172 	//------------------------------------//

  1173 	if (!error)

  1174 		{

  1175 		INFO_PRINTF1(_L("Getting Log"));

  1177 		TBuf8<64> memFunctionText;

  1179 		TUid uid = {KMmfTestControllerUid};

  1180 		TMMFMessageDestination handleInfo(uid);

  1181 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1183 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1185 		TBuf<64> memFunctionText16;

  1186 		memFunctionText16.Copy(memFunctionText);

  1187 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1189 		if (memFunctionText != KExpectedResult)

  1190 			{

  1191 			verdict = EFail;

  1192 			}

  1194 		}

  1195 	//------------------------------------//

  1197 	INFO_PRINTF1(_L("Closing Controller"));

  1198 	controller.Close();

  1200 	if (error)

  1201 		{

  1202 		verdict = EFail;

  1203 		}

  1205 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1206 	__MM_HEAP_MARKEND;

  1208 	return verdict;

  1209 	}

  1211 //------------------------------------------------------------------

  1213 CTestStep_MMF_CTLFRM_U_0018::CTestStep_MMF_CTLFRM_U_0018()

  1214 	/** Constructor

  1215 	*/

  1216 	{

  1217 	// store the name of this test case

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

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

  1220 	iTestStepName = _L("MM-MMF-CTLFRM-U-0018");

  1223 	}

  1225 TVerdict CTestStep_MMF_CTLFRM_U_0018::DoTestStepL( void )

  1226 /** As TSU_MMF_CTLFRM_U_0013

  1227  * ::GetPosition(..)

  1228  * Use case: N/A

  1229  * @test Req. under test REQ172.5.5 REQ172.5.5.10

  1230  */

  1231 	{

  1232 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1233 	__MM_HEAP_MARK;

  1235 	TVerdict verdict = EPass;

  1236 	_LIT8(KExpectedResult, "PositionL Called");

  1238 	TMMFPrioritySettings settings;

  1239 	TInt error = KErrNone;

  1240 	RMMFController controller;

  1242 	settings.iPriority = 1;

  1243 	settings.iPref = EMdaPriorityPreferenceTime;

  1244 	settings.iState = EMMFStateIdle;

  1246 	error = controller.Open(KTstControllerUid,settings);

  1247 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1249 	const TInt64 interval = 5;

  1250 	TTimeIntervalMicroSeconds position(interval);

  1252 	const TInt64 expectedInterval = 16;

  1253 	TTimeIntervalMicroSeconds expectedPosition(expectedInterval);

  1255 	// Get Position Controller

  1256 	if (!error)

  1257 		{

  1258 		INFO_PRINTF1(_L("API TEST: Calling GetPosition"));

  1259 		error = controller.GetPosition(position);

  1260 		}

  1262 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  1263 	INFO_PRINTF2(_L("Expected Position: %d"), I64LOW(expectedPosition.Int64()));

  1264 	INFO_PRINTF2(_L("Current Position: %d"), I64LOW(position.Int64()));

  1267 	if (expectedPosition != position)

  1268 		{

  1269 		INFO_PRINTF1(_L("Getting Log"));

  1271 		TBuf8<64> memFunctionText;

  1273 		TUid uid = {KMmfTestControllerUid};

  1274 		TMMFMessageDestination handleInfo(uid);

  1275 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1277 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1279 		TBuf<64> memFunctionText16;

  1280 		memFunctionText16.Copy(memFunctionText);

  1281 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1283 		if (memFunctionText != KExpectedResult)

  1284 			{

  1285 			verdict = EFail;

  1286 			}

  1287 		}

  1289 	INFO_PRINTF1(_L("Closing Controller"));

  1290 	controller.Close();

  1292 	if (error)

  1293 		{

  1294 		verdict = EFail;

  1295 		}

  1297 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1298 	__MM_HEAP_MARKEND;

  1300 	return verdict;

  1301 	}

  1303 //------------------------------------------------------------------

  1305 CTestStep_MMF_CTLFRM_U_0019::CTestStep_MMF_CTLFRM_U_0019()

  1306 	/** Constructor

  1307 	*/

  1308 	{

  1309 	// store the name of this test case

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

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

  1312 	iTestStepName = _L("MM-MMF-CTLFRM-U-0019");

  1315 	}

  1317 TVerdict CTestStep_MMF_CTLFRM_U_0019::DoTestStepL( void )

  1318 /** As TSU_MMF_CTLFRM_U_0013

  1319  * ::SetPosition(..)

  1320  * Use case: N/A

  1321  * @test Req. under test REQ172.5.5 REQ172.5.5.11

  1322  */

  1323 	{

  1324 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1325 	__MM_HEAP_MARK;

  1327 	TVerdict verdict = EPass;

  1328 	_LIT8(KExpectedResult, "SetPositionL Called");

  1330 	TMMFPrioritySettings settings;

  1331 	TInt error = KErrNone;

  1332 	RMMFController controller;

  1334 	settings.iPriority = 1;

  1335 	settings.iPref = EMdaPriorityPreferenceTime;

  1336 	settings.iState = EMMFStateIdle;

  1338 	error = controller.Open(KTstControllerUid,settings);

  1339 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1341 	const TInt64 interval = 5;

  1342 	TTimeIntervalMicroSeconds position(interval);

  1344 	// Set Position Controller

  1345 	if (!error)

  1346 		{

  1347 		INFO_PRINTF1(_L("API TEST: Calling SetPosition"));

  1348 		error = controller.SetPosition(position);

  1349 		}

  1351 	if (!error)

  1352 		error = controller.GetPosition(position);

  1355 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  1356 	INFO_PRINTF2(_L("Current Position: %d"), position.Int64());

  1358 	//------------------------------------//

  1359 	// Getting Log from Custom Controller //

  1360 	//------------------------------------//

  1361 	if (!error)

  1362 		{

  1363 		INFO_PRINTF1(_L("Getting Log"));

  1365 		TBuf8<64> memFunctionText;

  1367 		TUid uid = {KMmfTestControllerUid};

  1368 		TMMFMessageDestination handleInfo(uid);

  1369 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1371 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1373 		TBuf<64> memFunctionText16;

  1374 		memFunctionText16.Copy(memFunctionText);

  1375 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1377 		if (memFunctionText != KExpectedResult)

  1378 			{

  1379 			verdict = EFail;

  1380 			}

  1382 		}

  1383 	//------------------------------------//

  1385 	INFO_PRINTF1(_L("Closing Controller"));

  1386 	controller.Close();

  1388 	if (error)

  1389 		{

  1390 		verdict = EFail;

  1391 		}

  1393 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1394 	__MM_HEAP_MARKEND;

  1396 	return verdict;

  1397 	}

  1399 //------------------------------------------------------------------

  1401 CTestStep_MMF_CTLFRM_U_0020::CTestStep_MMF_CTLFRM_U_0020()

  1402 	/** Constructor

  1403 	*/

  1404 	{

  1405 	// store the name of this test case

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

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

  1408 	iTestStepName = _L("MM-MMF-CTLFRM-U-0020");

  1411 	}

  1413 TVerdict CTestStep_MMF_CTLFRM_U_0020::DoTestStepL( void )

  1414 /** As TSU_MMF_CTLFRM_U_0013

  1415  * ::GetDuration(..)

  1416  * Use case: N/A

  1417  * @test Req. under test No Requirement Found

  1418  */

  1419 	{

  1420 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1421 	__MM_HEAP_MARK;

  1423 	TVerdict verdict = EPass;

  1425 	TMMFPrioritySettings settings;

  1426 	TInt error = KErrNone;

  1427 	RMMFController controller;

  1429 	settings.iPriority = 1;

  1430 	settings.iPref = EMdaPriorityPreferenceTime;

  1431 	settings.iState = EMMFStateIdle;

  1433 	error = controller.Open(KTstControllerUid,settings);

  1434 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1436 	const TInt64 interval = 5;

  1437 	TTimeIntervalMicroSeconds duration(interval);

  1439 	const TInt64 expectedInterval = 36;

  1440 	TTimeIntervalMicroSeconds expectedDuration(expectedInterval);

  1442 	if (!error)

  1443 		{

  1444 		INFO_PRINTF1(_L("API TEST: Calling GetDuration"));

  1445 		error = controller.GetDuration(duration);

  1446 		}

  1449 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  1450 	INFO_PRINTF2(_L("Current Duration: %d"), I64LOW(expectedDuration.Int64()));

  1451 	INFO_PRINTF2(_L("Current Duration: %d"), I64LOW(duration.Int64()));

  1453 	if (duration != expectedDuration)

  1454 		{

  1455 		verdict = EFail;

  1456 		}

  1458 	INFO_PRINTF1(_L("Closing Controller"));

  1459 	controller.Close();

  1461 	if (error)

  1462 		{

  1463 		verdict = EFail;

  1464 		}

  1466 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1467 	__MM_HEAP_MARKEND;

  1469 	return verdict;

  1470 	}

  1473 //------------------------------------------------------------------

  1475 CTestStep_MMF_CTLFRM_U_0021::CTestStep_MMF_CTLFRM_U_0021()

  1476 	/** Constructor

  1477 	*/

  1478 	{

  1479 	// store the name of this test case

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

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

  1482 	iTestStepName = _L("MM-MMF-CTLFRM-U-0021");

  1485 	}

  1487 TVerdict CTestStep_MMF_CTLFRM_U_0021::DoTestStepL( void )

  1488 /** As TSU_MMF_CTLFRM_U_0013

  1489  * ::GetNumberOfMetaDataEntries(..)

  1490  * Use case: N/A

  1491  * @test Req. under test No Requirement Found

  1492  */

  1493 	{

  1494 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1495 	__MM_HEAP_MARK;

  1497 	TVerdict verdict = EPass;

  1498 	_LIT8(KExpectedResult, "GetNumberOfMetaDataEntriesL Called");

  1500 	TInt numberOfEntries = 0;

  1502 	TMMFPrioritySettings settings;

  1503 	TInt error = KErrNone;

  1504 	RMMFController controller;

  1506 	settings.iPriority = 1;

  1507 	settings.iPref = EMdaPriorityPreferenceTime;

  1508 	settings.iState = EMMFStateIdle;

  1510 	error = controller.Open(KTstControllerUid,settings);

  1511 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1514 	// Add Source and Sink

  1515 	INFO_PRINTF1(_L("Attempting to add a Source and a Sink to Controller"));

  1517 	if (!error)

  1518 		{

  1519 		INFO_PRINTF1(_L("API TEST: Calling GetNumberOfMetaDataEntries"));

  1520 		error = controller.GetNumberOfMetaDataEntries(numberOfEntries);

  1521 		}

  1523 	INFO_PRINTF2(_L("Number of Meta entries is: %d"), numberOfEntries);

  1525 	//------------------------------------//

  1526 	// Getting Log from Custom Controller //

  1527 	//------------------------------------//

  1528 	if (!error)

  1529 		{

  1530 		INFO_PRINTF1(_L("Getting Log"));

  1532 		TBuf8<64> memFunctionText;

  1534 		TUid uid = {KMmfTestControllerUid};

  1535 		TMMFMessageDestination handleInfo(uid);

  1536 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1538 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1540 		TBuf<64> memFunctionText16;

  1541 		memFunctionText16.Copy(memFunctionText);

  1542 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1544 		if (memFunctionText != KExpectedResult)

  1545 			{

  1546 			verdict = EFail;

  1547 			}

  1549 		}

  1550 	//------------------------------------//

  1552 	INFO_PRINTF1(_L("Closing Controller"));

  1553 	controller.Close();

  1555 	if (error)

  1556 		{

  1557 		verdict = EFail;

  1558 		}

  1560 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1561 	__MM_HEAP_MARKEND;

  1563 	return verdict;

  1564 	}

  1566 //------------------------------------------------------------------

  1568 CTestStep_MMF_CTLFRM_U_0022::CTestStep_MMF_CTLFRM_U_0022()

  1569 	/** Constructor

  1570 	*/

  1571 	{

  1572 	// store the name of this test case

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

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

  1575 	iTestStepName = _L("MM-MMF-CTLFRM-U-0022");

  1578 	}

  1580 TVerdict CTestStep_MMF_CTLFRM_U_0022::DoTestStepL( void )

  1581 /** As TSU_MMF_CTLFRM_U_0013

  1582  * ::GetMetaDataEntry(..)

  1583  * Use case: N/A

  1584  * @test Req. under test No Requirement Found

  1585  */

  1586 	{

  1587 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1588 	__MM_HEAP_MARK;

  1590 	TVerdict verdict = EPass;

  1591 	_LIT8(KExpectedResult, "GetMetaDataEntryL Called");

  1593 	TMMFPrioritySettings settings;

  1594 	TInt error = KErrNone;

  1595 	RMMFController controller;

  1597 	settings.iPriority = 1;

  1598 	settings.iPref = EMdaPriorityPreferenceTime;

  1599 	settings.iState = EMMFStateIdle;

  1601 	error = controller.Open(KTstControllerUid,settings);

  1602 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1604 	if (!error)

  1605 		{

  1606 		TInt indexOfEntry = 1;

  1607 		INFO_PRINTF1(_L("API TEST: Calling GetMetaDataEntryL"));

  1608 		CMMFMetaDataEntry* metaEntry = controller.GetMetaDataEntryL(indexOfEntry);

  1609 		CleanupStack::PushL(metaEntry);

  1610 		INFO_PRINTF2(_L("AudioLevel is: %S"), &metaEntry->Value());

  1612 		CleanupStack::PopAndDestroy(1);

  1613 		}

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

  1616 	// Getting Log from Custom Controller //

  1617 	//------------------------------------//

  1618 	if (!error)

  1619 		{

  1620 		INFO_PRINTF1(_L("Getting Log"));

  1622 		TBuf8<64> memFunctionText;

  1624 		TUid uid = {KMmfTestControllerUid};

  1625 		TMMFMessageDestination handleInfo(uid);

  1626 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1628 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1630 		TBuf<64> memFunctionText16;

  1631 		memFunctionText16.Copy(memFunctionText);

  1632 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1634 		if (memFunctionText != KExpectedResult)

  1635 			{

  1636 			verdict = EFail;

  1637 			}

  1639 		}

  1640 	//------------------------------------//

  1642 	INFO_PRINTF1(_L("Closing Controller"));

  1643 	controller.Close();

  1645 	if (error)

  1646 		{

  1647 		verdict = EFail;

  1648 		}

  1650 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1651 	__MM_HEAP_MARKEND;

  1653 	return verdict;

  1654 	}

  1656 //------------------------------------------------------------------

  1658 CTestStep_MMF_CTLFRM_U_0023::CTestStep_MMF_CTLFRM_U_0023()

  1659 	/** Constructor

  1660 	*/

  1661 	{

  1662 	// store the name of this test case

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

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

  1665 	iTestStepName = _L("MM-MMF-CTLFRM-U-0023");

  1668 	}

  1670 TVerdict CTestStep_MMF_CTLFRM_U_0023::DoTestStepL( void )

  1671 /** As TSU_MMF_CTLFRM_U_0013

  1672  * ::CustomSommandSync(..)

  1673  * Use case: N/A

  1674  * @test Req. under test REQ172.5.5 REQ172.5.5.14

  1675  */

  1676 	{

  1677 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1678 	__MM_HEAP_MARK;

  1680 	TVerdict verdict = EPass;

  1681 	_LIT8(KExpectedResult, "KDummyFunc1 Called");

  1683 	TMMFPrioritySettings settings;

  1684 	TInt error = KErrNone;

  1685 	RMMFController controller;

  1687 	settings.iPriority = 1;

  1688 	settings.iPref = EMdaPriorityPreferenceTime;

  1689 	settings.iState = EMMFStateIdle;

  1691 	// Open a Custom Controller

  1692 	error = controller.Open(KTstControllerUid,settings);

  1693 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1695 	if (!error)

  1696 		{

  1697 		INFO_PRINTF1(_L("Calling CustomCommandSync"));

  1698 		TMMFMessageDestinationPckg messageDest;

  1700 		const TInt interval = 5;

  1701 		TTimeIntervalMicroSeconds randomData(interval);

  1702 		TTimeIntervalMicroSeconds randomData2(interval+1);

  1703 		TTimeIntervalMicroSeconds randomData3(interval+2);

  1705 		TPckgBuf<TTimeIntervalMicroSeconds> randomDataPckg = randomData;

  1706 		TPckgBuf<TTimeIntervalMicroSeconds> randomData2Pckg = randomData2;

  1707 		TPckgBuf<TTimeIntervalMicroSeconds> randomData3Pckg = randomData3;

  1709 		error = controller.CustomCommandSync(messageDest, KDummyFunc1, randomDataPckg, randomData2Pckg, randomData3Pckg);

  1710 		}

  1712 	//------------------------------------//

  1713 	// Getting Log from Custom Controller //

  1714 	//------------------------------------//

  1715 	if (!error)

  1716 		{

  1717 		INFO_PRINTF1(_L("Getting Log"));

  1719 		TBuf8<64> memFunctionText;

  1721 		TUid uid = {KMmfTestControllerUid};

  1722 		TMMFMessageDestination handleInfo(uid);

  1723 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1725 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1727 		TBuf<64> memFunctionText16;

  1728 		memFunctionText16.Copy(memFunctionText);

  1729 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1731 		if (memFunctionText != KExpectedResult)

  1732 			{

  1733 			verdict = EFail;

  1734 			}

  1736 		}

  1737 	//------------------------------------//

  1739 	if (error)

  1740 		{

  1741 		verdict = EFail;

  1742 		}

  1744 	INFO_PRINTF1(_L("Closing Controller"));

  1745 	controller.Close();

  1747 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1748 	__MM_HEAP_MARKEND;

  1750 	return verdict;

  1751 	}

  1753 //------------------------------------------------------------------

  1755 CTestStep_MMF_CTLFRM_U_0024::CTestStep_MMF_CTLFRM_U_0024()

  1756 	/** Constructor

  1757 	*/

  1758 	{

  1759 	// store the name of this test case

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

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

  1762 	iTestStepName = _L("MM-MMF-CTLFRM-U-0024");

  1765 	}

  1767 TVerdict CTestStep_MMF_CTLFRM_U_0024::DoTestStepL( void )

  1768 /** As TSU_MMF_CTLFRM_U_0013

  1769  * ::CustomCommandAsync(..)

  1770  * Use case: N/A

  1771  * @test Req. under test REQ172.5.5 REQ172.5.5.14

  1772  */

  1773 	{

  1774 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1775 	__MM_HEAP_MARK;

  1777 	TVerdict verdict = EPass;

  1778 	_LIT8(KExpectedResult, "KDummyFunc1 Called");

  1780 	TMMFPrioritySettings settings;

  1781 	TInt error = KErrNone;

  1782 	RMMFController controller;

  1784 	settings.iPriority = 1;

  1785 	settings.iPref = EMdaPriorityPreferenceTime;

  1786 	settings.iState = EMMFStateIdle;

  1789 	// Open a Custom Controller

  1790 	error = controller.Open(KTstControllerUid,settings);

  1791 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1793 	if (!error)

  1794 		{

  1795 		INFO_PRINTF1(_L("Calling CustomCommandSync"));

  1796 		TMMFMessageDestinationPckg messageDest;

  1798 		const TInt interval = 5;

  1799 		TTimeIntervalMicroSeconds randomData(interval);

  1800 		TTimeIntervalMicroSeconds randomData2(interval+1);

  1801 		TTimeIntervalMicroSeconds randomData3(interval+2);

  1803 		TPckgBuf<TTimeIntervalMicroSeconds> randomDataPckg = randomData;

  1804 		TPckgBuf<TTimeIntervalMicroSeconds> randomData2Pckg = randomData2;

  1805 		TPckgBuf<TTimeIntervalMicroSeconds> randomData3Pckg = randomData3;

  1807 		TRequestStatus stat;

  1808 		controller.CustomCommandAsync(messageDest, KDummyFunc1, randomDataPckg, randomData2Pckg, randomData3Pckg, stat);

  1809 		User::WaitForRequest(stat);

  1810 		error = stat.Int();

  1811 		}

  1813 	//------------------------------------//

  1814 	// Getting Log from Custom Controller //

  1815 	//------------------------------------//

  1816 	if (!error)

  1817 		{

  1818 		INFO_PRINTF1(_L("Getting Log"));

  1820 		TBuf8<64> memFunctionText;

  1822 		TUid uid = {KMmfTestControllerUid};

  1823 		TMMFMessageDestination handleInfo(uid);

  1824 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1826 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1828 		TBuf<64> memFunctionText16;

  1829 		memFunctionText16.Copy(memFunctionText);

  1830 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1832 		if (memFunctionText != KExpectedResult)

  1833 			{

  1834 			verdict = EFail;

  1835 			}

  1837 		}

  1838 	//------------------------------------//

  1840 	if (error)

  1841 		{

  1842 		verdict = EFail;

  1843 		}

  1845 	INFO_PRINTF1(_L("Closing Controller"));

  1846 	controller.Close();

  1848 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1849 	__MM_HEAP_MARKEND;

  1851 	return verdict;

  1852 	}

  1854 //------------------------------------------------------------------

  1856 CTestStep_MMF_CTLFRM_U_0027::CTestStep_MMF_CTLFRM_U_0027()

  1857 	/** Constructor

  1858 	*/

  1859 	{

  1860 	// store the name of this test case

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

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

  1863 	iTestStepName = _L("MM-MMF-CTLFRM-U-0027");

  1866 	}

  1868 TVerdict CTestStep_MMF_CTLFRM_U_0027::DoTestStepL( void )

  1869 /** As TSU_MMF_CTLFRM_U_0013

  1870  * ::GetAudioQuality(..)

  1871  * Use case: N/A

  1872  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  1873  */

  1874 	{

  1875 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1876 	__MM_HEAP_MARK;

  1878 	TVerdict verdict = EPass;

  1879 	_LIT8(KExpectedResult, "GetAudioQuality Called");

  1881 	TMMFPrioritySettings settings;

  1882 	TInt error = KErrNone;

  1883 	RMMFController controller;

  1885 	settings.iPriority = 1;

  1886 	settings.iPref = EMdaPriorityPreferenceTime;

  1887 	settings.iState = EMMFStateIdle;

  1890 	// Open a Custom Controller

  1891 	error = controller.Open(KTstControllerUid,settings);

  1892 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1893 	TUid uid = {0x101f72B4};

  1895 	RMMFTestCustomCommands customCommands(controller,uid);

  1897 	TInt audioQuality;

  1898 	error = customCommands.GetAudioQuality(audioQuality);

  1900 	//------------------------------------//

  1901 	// Getting Log from Custom Controller //

  1902 	//------------------------------------//

  1903 	if (!error)

  1904 		{

  1905 		INFO_PRINTF1(_L("Getting Log"));

  1907 		TBuf8<64> memFunctionText;

  1909 		TUid uid = {KMmfTestControllerUid};

  1910 		TMMFMessageDestination handleInfo(uid);

  1911 		TMMFMessageDestinationPckg messageDest(handleInfo);

  1913 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  1915 		TBuf<64> memFunctionText16;

  1916 		memFunctionText16.Copy(memFunctionText);

  1917 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  1919 		if (memFunctionText != KExpectedResult)

  1920 			{

  1921 			verdict = EFail;

  1922 			}

  1924 		}

  1925 	//------------------------------------//

  1928 	if (error)

  1929 		{

  1930 		verdict = EFail;

  1931 		}

  1933 	INFO_PRINTF1(_L("Closing Controller"));

  1934 	controller.Close();

  1936 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  1937 	__MM_HEAP_MARKEND;

  1939 	return verdict;

  1940 	}

  1942 //------------------------------------------------------------------

  1944 CTestStep_MMF_CTLFRM_U_0028::CTestStep_MMF_CTLFRM_U_0028()

  1945 	/** Constructor

  1946 	*/

  1947 	{

  1948 	// store the name of this test case

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

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

  1951 	iTestStepName = _L("MM-MMF-CTLFRM-U-0028");

  1954 	}

  1956 TVerdict CTestStep_MMF_CTLFRM_U_0028::DoTestStepL( void )

  1957 /** As TSU_MMF_CTLFRM_U_0013

  1958  * ::SetAudioQuality(..)

  1959  * Use case: N/A

  1960  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  1961  */

  1962 	{

  1963 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  1964 	__MM_HEAP_MARK;

  1966 	TVerdict verdict = EPass;

  1967 	_LIT8(KExpectedResult, "SetAudioQuality Called");

  1970 	TMMFPrioritySettings settings;

  1971 	TInt error = KErrNone;

  1972 	RMMFController controller;

  1974 	settings.iPriority = 1;

  1975 	settings.iPref = EMdaPriorityPreferenceTime;

  1976 	settings.iState = EMMFStateIdle;

  1979 	// Open a Custom Controller

  1980 	error = controller.Open(KTstControllerUid,settings);

  1981 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  1982 	TUid uid = {0x101f72B4};

  1984 	RMMFTestCustomCommands customCommands(controller,uid);

  1987 	TInt audioQuality = 14;

  1989 	error = customCommands.SetAudioQuality(audioQuality);

  1991 	//------------------------------------//

  1992 	// Getting Log from Custom Controller //

  1993 	//------------------------------------//

  1994 	if (!error)

  1995 		{

  1996 		INFO_PRINTF1(_L("Getting Log"));

  1998 		TBuf8<64> memFunctionText;

  2000 		TUid uid = {KMmfTestControllerUid};

  2001 		TMMFMessageDestination handleInfo(uid);

  2002 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2004 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  2006 		TBuf<64> memFunctionText16;

  2007 		memFunctionText16.Copy(memFunctionText);

  2008 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  2010 		if (memFunctionText != KExpectedResult)

  2011 			{

  2012 			verdict = EFail;

  2013 			}

  2015 		}

  2016 	//------------------------------------//

  2019 	if (error)

  2020 		{

  2021 		verdict = EFail;

  2022 		}

  2024 	INFO_PRINTF1(_L("Closing Controller"));

  2025 	controller.Close();

  2027 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2028 	__MM_HEAP_MARKEND;

  2030 	return verdict;

  2031 	}

  2033 //------------------------------------------------------------------

  2034 // This test is supposed to fail

  2036 CTestStep_MMF_CTLFRM_U_0029::CTestStep_MMF_CTLFRM_U_0029()

  2037 	/** Constructor

  2038 	*/

  2039 	{

  2040 	// store the name of this test case

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

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

  2043 	iTestStepName = _L("MM-MMF-CTLFRM-U-0029");

  2046 	}

  2048 TVerdict CTestStep_MMF_CTLFRM_U_0029::DoTestStepL( void )

  2049 /** Call the RMMFController::Open(..) with the parameters specified, varify the

  2050  *  return value is NOT 0. Call the RMMFController::Close() on the Custom Controller.

  2051  *  Varify 'error' is NOT zero.

  2053  * Use case: N/A

  2054  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2055  */

  2056 	{

  2057 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2058 	__MM_HEAP_MARK;

  2060 	TVerdict verdict = EPass;

  2061 	INFO_PRINTF1(_L("Test to Fail to Open a Custom Controller"));

  2064 	TMMFPrioritySettings settings;

  2065 	TInt error = KErrNone;

  2066 	RMMFController controller;

  2068 	settings.iPriority = 1;

  2069 	settings.iPref = EMdaPriorityPreferenceTime;

  2070 	settings.iState = EMMFStateIdle;

  2072 	// Dummy UID to try and instantiate a controller which does not exist

  2073 	TUid uidDummy = {0x12345678};

  2075 	// Open a Custom Controller

  2076 	error = controller.Open(uidDummy,settings);

  2077 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2079 	if (!error)

  2080 		{

  2081 		verdict = EFail;

  2082 		}

  2084 	INFO_PRINTF1(_L("Closing Controller"));

  2085 	controller.Close();

  2087 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2088 	__MM_HEAP_MARKEND;

  2090 	return verdict;

  2091 	}

  2093 //------------------------------------------------------------------

  2095 CTestStep_MMF_CTLFRM_U_0030::CTestStep_MMF_CTLFRM_U_0030()

  2096 	/** Constructor

  2097 	*/

  2098 	{

  2099 	// store the name of this test case

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

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

  2102 	iTestStepName = _L("MM-MMF-CTLFRM-U-0030");

  2105 	}

  2107 TVerdict CTestStep_MMF_CTLFRM_U_0030::DoTestStepL( void )

  2108 /** Call the RMMFController::Open(..) (with the parameters from test 001), varify

  2109  *  the return value is 0. Fail to Instantiate a Custom DataSource Object and add it to

  2110  *  the Custom Controller using RMMFController::AddDataSource(..), with the specified

  2111  *  parameters. Call Custom Command 'KLogFunction' and varify the text value returned is

  2112  *  not equal to the specifed text in Test Step. Call the RMMFController::Close() on the

  2113  *  Custom Controller. Varify 'error' is NOT zero.

  2115  * Use case: N/A

  2116  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2117  */

  2118 	{

  2119 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2120 	__MM_HEAP_MARK;

  2122 	TVerdict verdict = EPass;

  2124 	INFO_PRINTF1(_L("Test to Fail to Open a Data Source"));

  2126 	TMMFPrioritySettings settings;

  2127 	TInt error = KErrNone;

  2128 	RMMFController controller;

  2130 	settings.iPriority = 1;

  2131 	settings.iPref = EMdaPriorityPreferenceTime;

  2132 	settings.iState = EMMFStateIdle;

  2134 	error = controller.Open(KTstControllerUid,settings);

  2135 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2137 	const TDesC8& initData = KInitData;

  2138 	TUid uidDummy = {0x12345678};

  2140 	// Add Source

  2141 	INFO_PRINTF1(_L("Attempting to add a Source to Controller"));

  2142 	if (!error)

  2143 		{

  2144 		INFO_PRINTF1(_L("API TEST: Calling AddDataSource"));

  2145 		error = controller.AddDataSource(uidDummy, initData);

  2146 		}

  2148 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  2150 	INFO_PRINTF1(_L("Closing Controller"));

  2151 	controller.Close();

  2153 	if (!error)

  2154 		{

  2155 		verdict = EFail;

  2156 		}

  2158 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2159 	__MM_HEAP_MARKEND;

  2161 	return verdict;

  2162 	}

  2165 //---------------------------------------------------------------------

  2167 CTestStep_MMF_CTLFRM_U_0031::CTestStep_MMF_CTLFRM_U_0031()

  2168 	/** Constructor

  2169 	*/

  2170 	{

  2171 	// store the name of this test case

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

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

  2174 	iTestStepName = _L("MM-MMF-CTLFRM-U-0031");

  2177 	}

  2179 TVerdict CTestStep_MMF_CTLFRM_U_0031::DoTestStepL( void )

  2180 /** Call the RMMFController::Open(..) (with the parameters from test 001), varify the

  2181  *  return value is 0. Instantiate a Custom DataSink Object and add it to the Custom

  2182  *  Controller using RMMFController::AddDataSink(..), with the specified parameters. Call

  2183  *  Custom Command 'KLogFunction' and varify the text value returned is equal to the

  2184  *  specifed text in Test Step. Call the RMMFController::Close() on the Custom Controller.

  2185  *  Varify 'error' is zero.

  2187  * Use case: N/A

  2188  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2189  */

  2190 	{

  2191 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2192 	__MM_HEAP_MARK;

  2194 	TVerdict verdict = EPass;

  2196 	INFO_PRINTF1(_L("Test to Fail to Open a Data Sink"));

  2198 	TMMFPrioritySettings settings;

  2199 	TInt error = KErrNone;

  2200 	RMMFController controller;

  2202 	settings.iPriority = 1;

  2203 	settings.iPref = EMdaPriorityPreferenceTime;

  2204 	settings.iState = EMMFStateIdle;

  2206 	error = controller.Open(KTstControllerUid,settings);

  2208 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2210 	const TDesC8& initData = KInitData;

  2211 	TUid uidDummy = {0x12345678};

  2213 	// Add Source

  2214 	INFO_PRINTF1(_L("Attempting to add a Sink to Controller"));

  2215 	if (!error)

  2216 		{

  2217 		INFO_PRINTF1(_L("API TEST: Calling AddDataSource"));

  2218 		error = controller.AddDataSink(uidDummy, initData);

  2219 		}

  2221 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  2223 	INFO_PRINTF1(_L("Closing Controller"));

  2224 	controller.Close();

  2226 	if (!error)

  2227 		{

  2228 		verdict = EFail;

  2229 		}

  2231 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2232 	__MM_HEAP_MARKEND;

  2234 	return verdict;

  2235 	}

  2237 //----------------------------------------------------------

  2239 CTestStep_MMF_CTLFRM_U_0032::CTestStep_MMF_CTLFRM_U_0032()

  2240 	/** Constructor

  2241 	*/

  2242 	{

  2243 	// store the name of this test case

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

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

  2246 	iTestStepName = _L("MM-MMF-CTLFRM-U-0032");

  2249 	}

  2251 TVerdict CTestStep_MMF_CTLFRM_U_0032::DoTestStepL( void )

  2252 /** Verfiy CMMFDescriptorBuffer creation and deletion using default buffer size

  2253  * Use case: N/A

  2254  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2255  */

  2256 	{

  2257 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2258 	__MM_HEAP_MARK;

  2260 	TVerdict verdict = EPass;

  2262 	TMMFPrioritySettings settings;

  2263 	TInt error = KErrNone;

  2264 	RMMFController controller;

  2266 	settings.iPriority = 1;

  2267 	settings.iPref = EMdaPriorityPreferenceTime;

  2268 	settings.iState = EMMFStateIdle;

  2270 	error = controller.Open(KTstControllerUid,settings);

  2271 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2273 	//---------------------//

  2274 	// Set Controller Mode //

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

  2276 	if (!error)

  2277 		{

  2278 		TUid uid = {KMmfTestControllerUid};

  2279 		TMMFMessageDestination handleInfo(uid);

  2280 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2282 		TPckgBuf<TUint8> value = 1; // 1 = EFailure Mode

  2284 		error = controller.CustomCommandSync(messageDest, KModeFunction, value, KNullDesC8);

  2285 		}

  2287 	const TDesC8& initData = KInitData;

  2288 	TUid uidDummy = {0x12345678};

  2290 	// Add Source

  2291 	INFO_PRINTF1(_L("Attempting to add a Source to Controller"));

  2292 	if (!error)

  2293 		{

  2294 		INFO_PRINTF1(_L("API TEST: Calling AddDataSource"));

  2295 		//error = controller.AddDataSource(KTestDataSourceUid, initData);

  2296 		error = controller.AddDataSource(uidDummy, initData);

  2297 		}

  2299 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  2301 	if (error != KAddDataSourceFailure)

  2302 		{

  2303 		verdict = EFail;

  2304 		}

  2307 	INFO_PRINTF1(_L("Closing Controller"));

  2308 	controller.Close();

  2310 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2311 	__MM_HEAP_MARKEND;

  2313 	return verdict;

  2314 	}

  2316 //---------------------------------------------------------------

  2319 CTestStep_MMF_CTLFRM_U_0033::CTestStep_MMF_CTLFRM_U_0033()

  2320 	/** Constructor

  2321 	*/

  2322 	{

  2323 	// store the name of this test case

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

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

  2326 	iTestStepName = _L("MM-MMF-CTLFRM-U-0033");

  2329 	}

  2331 TVerdict CTestStep_MMF_CTLFRM_U_0033::DoTestStepL( void )

  2332 /** Verfiy CMMFDescriptorBuffer creation and deletion using default buffer size

  2333  * Use case: N/A

  2334  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2335  */

  2336 	{

  2337 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2338 	__MM_HEAP_MARK;

  2340 	TVerdict verdict = EPass;

  2342 	TMMFPrioritySettings settings;

  2343 	TInt error = KErrNone;

  2344 	RMMFController controller;

  2346 	settings.iPriority = 1;

  2347 	settings.iPref = EMdaPriorityPreferenceTime;

  2348 	settings.iState = EMMFStateIdle;

  2350 	error = controller.Open(KTstControllerUid,settings);

  2351 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2353 	//---------------------//

  2354 	// Set Controller Mode //

  2355 	//---------------------//

  2356 	if (!error)

  2357 		{

  2358 		TUid uid = {KMmfTestControllerUid};

  2359 		TMMFMessageDestination handleInfo(uid);

  2360 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2363 		TPckgBuf<TUint8> value = 1; // 1 = EFailure Mode

  2365 		error = controller.CustomCommandSync(messageDest, KModeFunction, value, KNullDesC8);

  2366 		}

  2368 	const TDesC8& initData = KInitData;

  2370 	// Add Sink

  2371 	INFO_PRINTF1(_L("Attempting to add a Sink to Controller"));

  2372 	if (!error)

  2373 		{

  2374 		INFO_PRINTF1(_L("API TEST: Calling AddDataSink"));

  2375 		error = controller.AddDataSource(KTestDataSinkUid, initData);

  2376 		}

  2378 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  2380 	if (error != KAddDataSinkFailure)

  2381 		{

  2382 		verdict = EFail;

  2383 		}

  2386 	INFO_PRINTF1(_L("Closing Controller"));

  2387 	controller.Close();

  2389 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2390 	__MM_HEAP_MARKEND;

  2392 	return verdict;

  2393 	}

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

  2398 CTestStep_MMF_CTLFRM_U_0034::CTestStep_MMF_CTLFRM_U_0034()

  2399 	/** Constructor

  2400 	*/

  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-CTLFRM-U-0034");

  2408 	}

  2410 TVerdict CTestStep_MMF_CTLFRM_U_0034::DoTestStepL( void )

  2411 /** Verfiy CMMFDescriptorBuffer creation and deletion using default buffer size

  2412  * Use case: N/A

  2413  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2414  */

  2415 	{

  2416 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2417 	__MM_HEAP_MARK;

  2419 	TVerdict verdict = EPass;

  2421 	TMMFPrioritySettings settings;

  2422 	TInt error = KErrNone;

  2423 	RMMFController controller;

  2425 	settings.iPriority = 1;

  2426 	settings.iPref = EMdaPriorityPreferenceTime;

  2427 	settings.iState = EMMFStateIdle;

  2429 	error = controller.Open(KTstControllerUid,settings);

  2430 	INFO_PRINTF2(_L("Controller Open: %d"), error);

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

  2433 	// Set Controller Mode //

  2434 	//---------------------//

  2435 	if (!error)

  2436 		{

  2437 		TUid uid = {KMmfTestControllerUid};

  2438 		TMMFMessageDestination handleInfo(uid);

  2439 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2441 		TPckgBuf<TUint8> value = 1; // 1 = EFailure Mode

  2443 		error = controller.CustomCommandSync(messageDest, KModeFunction, value, KNullDesC8);

  2444 		}

  2446 	const TDesC8& initData = KInitData;

  2447 	TMMFMessageDestination sourceHandlePtr;

  2448 	TMMFMessageDestination& sourceHandle = sourceHandlePtr;

  2450 	// Add Source

  2451 	INFO_PRINTF1(_L("Attempting to add a Source to Controller"));

  2452 	if (!error)

  2453 		{

  2454 		INFO_PRINTF1(_L("API TEST: Calling AddDataSource"));

  2455 		error = controller.AddDataSource(KTestDataSourceUid, initData, sourceHandle);

  2456 		error = controller.RemoveDataSource(sourceHandle);

  2457 		}

  2460 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  2462 	if (error != KAddDataSourceFailure)

  2463 		{

  2464 		verdict = EFail;

  2465 		}

  2468 	INFO_PRINTF1(_L("Closing Controller"));

  2469 	controller.Close();

  2471 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2472 	__MM_HEAP_MARKEND;

  2474 	return verdict;

  2475 	}

  2477 //-----------------------------------------------------------//

  2479 CTestStep_MMF_CTLFRM_U_0035::CTestStep_MMF_CTLFRM_U_0035()

  2480 	/** Constructor

  2481 	*/

  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-CTLFRM-U-0035");

  2489 	}

  2491 TVerdict CTestStep_MMF_CTLFRM_U_0035::DoTestStepL( void )

  2492 /** Verfiy CMMFDescriptorBuffer creation and deletion using default buffer size

  2493  * Use case: N/A

  2494  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2495  */

  2496 	{

  2497 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2498 	__MM_HEAP_MARK;

  2500 	TVerdict verdict = EPass;

  2502 	TMMFPrioritySettings settings;

  2503 	TInt error = KErrNone;

  2504 	RMMFController controller;

  2506 	settings.iPriority = 1;

  2507 	settings.iPref = EMdaPriorityPreferenceTime;

  2508 	settings.iState = EMMFStateIdle;

  2510 	error = controller.Open(KTstControllerUid,settings);

  2511 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2513 	//---------------------//

  2514 	// Set Controller Mode //

  2515 	//---------------------//

  2516 	if (!error)

  2517 		{

  2518 		TUid uid = {KMmfTestControllerUid};

  2519 		TMMFMessageDestination handleInfo(uid);

  2520 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2522 //		TUint8 value = 1; // 1 = EFailure Mode

  2523 		TPckgBuf<TUint8> value = 1;

  2525 		error = controller.CustomCommandSync(messageDest, KModeFunction, value, KNullDesC8);

  2526 		}

  2528 	const TDesC8& initData = KInitData;

  2529 	TMMFMessageDestination sinkHandlePtr;

  2530 	TMMFMessageDestination& sinkHandle = sinkHandlePtr;

  2532 	// Add Source

  2533 	INFO_PRINTF1(_L("Attempting to add a Sink to Controller"));

  2534 	if (!error)

  2535 		{

  2536 		INFO_PRINTF1(_L("API TEST: Calling AddDataSink"));

  2537 		error = controller.AddDataSink(KTestDataSinkUid, initData, sinkHandle);

  2538 		error = controller.RemoveDataSink(sinkHandle);

  2539 		}

  2542 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  2544 	if (error != KAddDataSinkFailure)

  2545 		{

  2546 		verdict = EFail;

  2547 		}

  2549 	INFO_PRINTF1(_L("Closing Controller"));

  2550 	controller.Close();

  2552 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2553 	__MM_HEAP_MARKEND;

  2555 	return verdict;

  2556 	}

  2558 //-----------------------------------------------------------//

  2562 //-----------------------------------------------------------

  2563 // Testing of the Standard Custom Commands

  2564 //-----------------------------------------------------------

  2566 CTestStep_MMF_CTLFRM_U_0040::CTestStep_MMF_CTLFRM_U_0040()

  2567 	/** Constructor

  2568 	*/

  2569 	{

  2570 	// store the name of this test case

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

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

  2573 	iTestStepName = _L("MM-MMF-CTLFRM-U-0040");

  2576 	}

  2578 TVerdict CTestStep_MMF_CTLFRM_U_0040::DoTestStepL( void )

  2579 /** Call the RMMFController::Open(..) (with the parameters from test 001), varify the

  2580  *  return value is 0. Instantiate a CustomCommands Object (specified). Call RMMFController

  2581  *  Method specified and varify the 'error' is 0. Follow this by calling the  Custom

  2582  *  Command 'KLogFunction' and varify the text value returned is equal to the specifed text

  2583  *  in Test Step. Call the RMMFController::Close() on the Custom Controller. Varify 'error'

  2584  *  is zero.

  2586  * Use case: N/A

  2587  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2588  */

  2589 	{

  2590 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2591 	__MM_HEAP_MARK;

  2593 	TVerdict verdict = EPass;

  2594 	_LIT8(KExpectedResult, "MapdSetVolumeL Called");

  2596 	TMMFPrioritySettings settings;

  2597 	TInt error = KErrNone;

  2598 	RMMFController controller;

  2600 	settings.iPriority = 1;

  2601 	settings.iPref = EMdaPriorityPreferenceTime;

  2602 	settings.iState = EMMFStateIdle;

  2604 	TInt volume = 27;

  2606 	// Open a Custom Controller

  2607 	error = controller.Open(KTstControllerUid,settings);

  2608 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2610 	RMMFAudioPlayDeviceCustomCommands customCommands(controller);

  2612 	error = customCommands.SetVolume(volume);

  2614 	//------------------------------------//

  2615 	// Getting Log from Custom Controller //

  2616 	//------------------------------------//

  2617 	if (!error)

  2618 		{

  2619 		INFO_PRINTF1(_L("Getting Log"));

  2621 		TBuf8<64> memFunctionText;

  2623 		TUid uid = {KMmfTestControllerUid};

  2624 		TMMFMessageDestination handleInfo(uid);

  2625 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2627 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  2629 		TBuf<64> memFunctionText16;

  2630 		memFunctionText16.Copy(memFunctionText);

  2631  		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  2633 		if (memFunctionText != KExpectedResult)

  2634 			{

  2635 			verdict = EFail;

  2636 			}

  2638 		}

  2639 	//------------------------------------//

  2641 	if (error)

  2642 		{

  2643 		verdict = EFail;

  2644 		}

  2646 	INFO_PRINTF1(_L("Closing Controller"));

  2647 	controller.Close();

  2649 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2650 	__MM_HEAP_MARKEND;

  2652 	return verdict;

  2653 	}

  2655 //---------------------------------------------------------------

  2658 CTestStep_MMF_CTLFRM_U_0041::CTestStep_MMF_CTLFRM_U_0041()

  2659 	/** Constructor

  2660 	*/

  2661 	{

  2662 	// store the name of this test case

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

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

  2665 	iTestStepName = _L("MM-MMF-CTLFRM-U-0041");

  2668 	}

  2670 TVerdict CTestStep_MMF_CTLFRM_U_0041::DoTestStepL( void )

  2671 /** As TSU_MMF_CTLFRM_U_0040

  2673  * Use case: N/A

  2674  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2675  */

  2676 	{

  2677 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2678 	__MM_HEAP_MARK;

  2680 	TVerdict verdict = EPass;

  2681 	_LIT8(KExpectedResult, "MapdGetMaxVolumeL Called");

  2683 	TMMFPrioritySettings settings;

  2684 	TInt error = KErrNone;

  2685 	RMMFController controller;

  2687 	settings.iPriority = 1;

  2688 	settings.iPref = EMdaPriorityPreferenceTime;

  2689 	settings.iState = EMMFStateIdle;

  2691 	TInt maxVolume = 0;

  2693 	// Open a Custom Controller

  2694 	error = controller.Open(KTstControllerUid,settings);

  2695 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2697 	RMMFAudioPlayDeviceCustomCommands customCommands(controller);

  2699 	error = customCommands.GetMaxVolume(maxVolume);

  2701 	//------------------------------------//

  2702 	// Getting Log from Custom Controller //

  2703 	//------------------------------------//

  2704 	if (!error)

  2705 		{

  2706 		INFO_PRINTF1(_L("Getting Log"));

  2708 		TBuf8<64> memFunctionText;

  2710 		TUid uid = {KMmfTestControllerUid};

  2711 		TMMFMessageDestination handleInfo(uid);

  2712 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2714 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  2716 		TBuf<64> memFunctionText16;

  2717 		memFunctionText16.Copy(memFunctionText);

  2718 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  2720 		if (memFunctionText != KExpectedResult)

  2721 			{

  2722 			verdict = EFail;

  2723 			}

  2725 		}

  2726 	//------------------------------------//

  2729 	if (error)

  2730 		{

  2731 		verdict = EFail;

  2732 		}

  2734 	INFO_PRINTF1(_L("Closing Controller"));

  2735 	controller.Close();

  2737 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2738 	__MM_HEAP_MARKEND;

  2740 	return verdict;

  2741 	}

  2743 //---------------------------------------------------------------

  2745 CTestStep_MMF_CTLFRM_U_0042::CTestStep_MMF_CTLFRM_U_0042()

  2746 	/** Constructor

  2747 	*/

  2748 	{

  2749 	// store the name of this test case

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

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

  2752 	iTestStepName = _L("MM-MMF-CTLFRM-U-0042");

  2755 	}

  2757 TVerdict CTestStep_MMF_CTLFRM_U_0042::DoTestStepL( void )

  2758 /** As TSU_MMF_CTLFRM_U_0040

  2759  * Use case: N/A

  2760  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2761  */

  2762 	{

  2763 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2764 	__MM_HEAP_MARK;

  2766 	TVerdict verdict = EPass;

  2767 	_LIT8(KExpectedResult, "MapdGetVolumeL Called");

  2769 	TMMFPrioritySettings settings;

  2770 	TInt error = KErrNone;

  2771 	RMMFController controller;

  2773 	settings.iPriority = 1;

  2774 	settings.iPref = EMdaPriorityPreferenceTime;

  2775 	settings.iState = EMMFStateIdle;

  2777 	TInt volume = 0;

  2779 	// Open a Custom Controller

  2780 	error = controller.Open(KTstControllerUid,settings);

  2781 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2783 	RMMFAudioPlayDeviceCustomCommands customCommands(controller);

  2785 	error = customCommands.GetVolume(volume);

  2787 	//------------------------------------//

  2788 	// Getting Log from Custom Controller //

  2789 	//------------------------------------//

  2790 	if (!error)

  2791 		{

  2792 		INFO_PRINTF1(_L("Getting Log"));

  2794 		TBuf8<64> memFunctionText;

  2796 		TUid uid = {KMmfTestControllerUid};

  2797 		TMMFMessageDestination handleInfo(uid);

  2798 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2800 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  2802 		TBuf<64> memFunctionText16;

  2803 		memFunctionText16.Copy(memFunctionText);

  2804 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  2806 		if (memFunctionText != KExpectedResult)

  2807 			{

  2808 			verdict = EFail;

  2809 			}

  2811 		}

  2812 	//------------------------------------//

  2814 	if (error)

  2815 		{

  2816 		verdict = EFail;

  2817 		}

  2819 	INFO_PRINTF1(_L("Closing Controller"));

  2820 	controller.Close();

  2822 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2823 	__MM_HEAP_MARKEND;

  2825 	return verdict;

  2826 	}

  2828 //---------------------------------------------------------------

  2831 CTestStep_MMF_CTLFRM_U_0043::CTestStep_MMF_CTLFRM_U_0043()

  2832 	/** Constructor

  2833 	*/

  2834 	{

  2835 	// store the name of this test case

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

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

  2838 	iTestStepName = _L("MM-MMF-CTLFRM-U-0043");

  2841 	}

  2843 TVerdict CTestStep_MMF_CTLFRM_U_0043::DoTestStepL( void )

  2844 /** As TSU_MMF_CTLFRM_U_0040

  2845  * Use case: N/A

  2846  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2847  */

  2848 	{

  2849 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2850 	__MM_HEAP_MARK;

  2852 	TVerdict verdict = EPass;

  2853 	_LIT8(KExpectedResult, "MapdSetVolumeRampL Called");

  2855 	TMMFPrioritySettings settings;

  2856 	TInt error = KErrNone;

  2857 	RMMFController controller;

  2859 	settings.iPriority = 1;

  2860 	settings.iPref = EMdaPriorityPreferenceTime;

  2861 	settings.iState = EMMFStateIdle;

  2863 	const TInt64 interval = 10;

  2864 	TTimeIntervalMicroSeconds rampData(interval);

  2866 	// Open a Custom Controller

  2867 	error = controller.Open(KTstControllerUid,settings);

  2868 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2870 	RMMFAudioPlayDeviceCustomCommands customCommands(controller);

  2872 	error = customCommands.SetVolumeRamp(rampData);

  2874 	//------------------------------------//

  2875 	// Getting Log from Custom Controller //

  2876 	//------------------------------------//

  2877 	if (!error)

  2878 		{

  2879 		INFO_PRINTF1(_L("Getting Log"));

  2881 		TBuf8<64> memFunctionText;

  2883 		TUid uid = {KMmfTestControllerUid};

  2884 		TMMFMessageDestination handleInfo(uid);

  2885 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2887 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  2889 		TBuf<64> memFunctionText16;

  2890 		memFunctionText16.Copy(memFunctionText);

  2891 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  2893 		if (memFunctionText != KExpectedResult)

  2894 			{

  2895 			verdict = EFail;

  2896 			}

  2898 		}

  2899 	//------------------------------------//

  2901 	if (error)

  2902 		{

  2903 		verdict = EFail;

  2904 		}

  2906 	INFO_PRINTF1(_L("Closing Controller"));

  2907 	controller.Close();

  2909 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2910 	__MM_HEAP_MARKEND;

  2912 	return verdict;

  2913 	}

  2915 //---------------------------------------------------------------

  2917 CTestStep_MMF_CTLFRM_U_0044::CTestStep_MMF_CTLFRM_U_0044()

  2918 	/** Constructor

  2919 	*/

  2920 	{

  2921 	// store the name of this test case

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

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

  2924 	iTestStepName = _L("MM-MMF-CTLFRM-U-0044");

  2927 	}

  2929 TVerdict CTestStep_MMF_CTLFRM_U_0044::DoTestStepL( void )

  2930 /** As TSU_MMF_CTLFRM_U_0040

  2931  * Use case: N/A

  2932  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  2933  */

  2934 	{

  2935 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  2936 	__MM_HEAP_MARK;

  2938 	TVerdict verdict = EPass;

  2939 	_LIT8(KExpectedResult, "MapdSetBalanceL Called");

  2941 	TMMFPrioritySettings settings;

  2942 	TInt error = KErrNone;

  2943 	RMMFController controller;

  2945 	settings.iPriority = 1;

  2946 	settings.iPref = EMdaPriorityPreferenceTime;

  2947 	settings.iState = EMMFStateIdle;

  2949 	TInt balance = 5;

  2951 	// Open a Custom Controller

  2952 	error = controller.Open(KTstControllerUid,settings);

  2953 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  2955 	RMMFAudioPlayDeviceCustomCommands customCommands(controller);

  2957 	error = customCommands.SetBalance(balance);

  2960 	//------------------------------------//

  2961 	// Getting Log from Custom Controller //

  2962 	//------------------------------------//

  2963 	if (!error)

  2964 		{

  2965 		INFO_PRINTF1(_L("Getting Log"));

  2967 		TBuf8<64> memFunctionText;

  2969 		TUid uid = {KMmfTestControllerUid};

  2970 		TMMFMessageDestination handleInfo(uid);

  2971 		TMMFMessageDestinationPckg messageDest(handleInfo);

  2973 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  2975 		TBuf<64> memFunctionText16;

  2976 		memFunctionText16.Copy(memFunctionText);

  2977 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  2979 		if (memFunctionText != KExpectedResult)

  2980 			{

  2981 			verdict = EFail;

  2982 			}

  2984 		}

  2985 	//------------------------------------//

  2988 	if (error)

  2989 		{

  2990 		verdict = EFail;

  2991 		}

  2993 	INFO_PRINTF1(_L("Closing Controller"));

  2994 	controller.Close();

  2996 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  2997 	__MM_HEAP_MARKEND;

  2999 	return verdict;

  3000 	}

  3002 //---------------------------------------------------------------

  3004 CTestStep_MMF_CTLFRM_U_0045::CTestStep_MMF_CTLFRM_U_0045()

  3005 	/** Constructor

  3006 	*/

  3007 	{

  3008 	// store the name of this test case

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

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

  3011 	iTestStepName = _L("MM-MMF-CTLFRM-U-0045");

  3014 	}

  3016 TVerdict CTestStep_MMF_CTLFRM_U_0045::DoTestStepL( void )

  3017 /** As TSU_MMF_CTLFRM_U_0040

  3018  * Use case: N/A

  3019  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3020  */

  3021 	{

  3022 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3023 	__MM_HEAP_MARK;

  3025 	TVerdict verdict = EPass;

  3026 	_LIT8(KExpectedResult, "MapdGetBalanceL Called");

  3028 	TMMFPrioritySettings settings;

  3029 	TInt error = KErrNone;

  3030 	RMMFController controller;

  3032 	settings.iPriority = 1;

  3033 	settings.iPref = EMdaPriorityPreferenceTime;

  3034 	settings.iState = EMMFStateIdle;

  3036 	TInt balance = 5;

  3038 	// Open a Custom Controller

  3039 	error = controller.Open(KTstControllerUid,settings);

  3040 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3042 	RMMFAudioPlayDeviceCustomCommands customCommands(controller);

  3044 	customCommands.GetBalance(balance);

  3046 	//------------------------------------//

  3047 	// Getting Log from Custom Controller //

  3048 	//------------------------------------//

  3049 	if (!error)

  3050 		{

  3051 		INFO_PRINTF1(_L("Getting Log"));

  3053 		TBuf8<64> memFunctionText;

  3055 		TUid uid = {KMmfTestControllerUid};

  3056 		TMMFMessageDestination handleInfo(uid);

  3057 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3059 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3061 		TBuf<64> memFunctionText16;

  3062 		memFunctionText16.Copy(memFunctionText);

  3063 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  3065 		if (memFunctionText != KExpectedResult)

  3066 			{

  3067 			verdict = EFail;

  3068 			}

  3070 		}

  3071 	//------------------------------------//

  3074 	if (error)

  3075 		{

  3076 		verdict = EFail;

  3077 		}

  3079 	INFO_PRINTF1(_L("Closing Controller"));

  3080 	controller.Close();

  3082 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3083 	__MM_HEAP_MARKEND;

  3085 	return verdict;

  3086 	}

  3088 //---------------------------------------------------------------

  3090 CTestStep_MMF_CTLFRM_U_0050::CTestStep_MMF_CTLFRM_U_0050()

  3091 	/** Constructor

  3092 	*/

  3093 	{

  3094 	// store the name of this test case

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

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

  3097 	iTestStepName = _L("MM-MMF-CTLFRM-U-0050");

  3100 	}

  3102 TVerdict CTestStep_MMF_CTLFRM_U_0050::DoTestStepL( void )

  3103 /** As TSU_MMF_CTLFRM_U_0040

  3104  * Use case: N/A

  3105  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3106  */

  3107 	{

  3108 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3109 	__MM_HEAP_MARK;

  3111 	TVerdict verdict = EPass;

  3112 	_LIT8(KExpectedResult, "MardSetGainL Called");

  3114 	TMMFPrioritySettings settings;

  3115 	TInt error = KErrNone;

  3116 	RMMFController controller;

  3118 	settings.iPriority = 1;

  3119 	settings.iPref = EMdaPriorityPreferenceTime;

  3120 	settings.iState = EMMFStateIdle;

  3122 	TInt gain = 5;

  3124 	// Open a Custom Controller

  3125 	error = controller.Open(KTstControllerUid,settings);

  3126 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3128 	RMMFAudioRecordDeviceCustomCommands customCommands(controller);

  3129 	error = customCommands.SetGain(gain);

  3131 	//------------------------------------//

  3132 	// Getting Log from Custom Controller //

  3133 	//------------------------------------//

  3134 	if (!error)

  3135 		{

  3136 		INFO_PRINTF1(_L("Getting Log"));

  3138 		TBuf8<64> memFunctionText;

  3140 		TUid uid = {KMmfTestControllerUid};

  3141 		TMMFMessageDestination handleInfo(uid);

  3142 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3144 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3146 		TBuf<64> memFunctionText16;

  3147 		memFunctionText16.Copy(memFunctionText);

  3148 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  3150 		if (memFunctionText != KExpectedResult)

  3151 			{

  3152 			verdict = EFail;

  3153 			}

  3155 		}

  3156 	//------------------------------------//

  3158 	if (error)

  3159 		{

  3160 		verdict = EFail;

  3161 		}

  3163 	INFO_PRINTF1(_L("Closing Controller"));

  3164 	controller.Close();

  3166 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3167 	__MM_HEAP_MARKEND;

  3169 	return verdict;

  3170 	}

  3172 //---------------------------------------------------------------

  3175 CTestStep_MMF_CTLFRM_U_0051::CTestStep_MMF_CTLFRM_U_0051()

  3176 	/** Constructor

  3177 	*/

  3178 	{

  3179 	// store the name of this test case

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

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

  3182 	iTestStepName = _L("MM-MMF-CTLFRM-U-0051");

  3185 	}

  3187 TVerdict CTestStep_MMF_CTLFRM_U_0051::DoTestStepL( void )

  3188 /** As TSU_MMF_CTLFRM_U_0040

  3189  * Use case: N/A

  3190  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3191  */

  3192 	{

  3193 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3194 	__MM_HEAP_MARK;

  3196 	TVerdict verdict = EPass;

  3197 	_LIT8(KExpectedResult, "MardGetMaxGainL Called");

  3199 	TMMFPrioritySettings settings;

  3200 	TInt error = KErrNone;

  3201 	RMMFController controller;

  3203 	settings.iPriority = 1;

  3204 	settings.iPref = EMdaPriorityPreferenceTime;

  3205 	settings.iState = EMMFStateIdle;

  3207 	TInt maxGain = 0;

  3209 	// Open a Custom Controller

  3210 	error = controller.Open(KTstControllerUid,settings);

  3211 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3213 	RMMFAudioRecordDeviceCustomCommands customCommands(controller);

  3214 	error = customCommands.GetMaxGain(maxGain);

  3216 	//------------------------------------//

  3217 	// Getting Log from Custom Controller //

  3218 	//------------------------------------//

  3219 	if (!error)

  3220 		{

  3221 		INFO_PRINTF1(_L("Getting Log"));

  3223 		TBuf8<64> memFunctionText;

  3225 		TUid uid = {KMmfTestControllerUid};

  3226 		TMMFMessageDestination handleInfo(uid);

  3227 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3229 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3231 		TBuf<64> memFunctionText16;

  3232 		memFunctionText16.Copy(memFunctionText);

  3233 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  3235 		if (memFunctionText != KExpectedResult)

  3236 			{

  3237 			verdict = EFail;

  3238 			}

  3240 		}

  3241 	//------------------------------------//

  3243 	INFO_PRINTF2(_L("Max Gain: %d"),maxGain);

  3246 	if (error)

  3247 		{

  3248 		verdict = EFail;

  3249 		}

  3251 	INFO_PRINTF1(_L("Closing Controller"));

  3252 	controller.Close();

  3254 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3255 	__MM_HEAP_MARKEND;

  3257 	return verdict;

  3258 	}

  3260 //---------------------------------------------------------------

  3262 CTestStep_MMF_CTLFRM_U_0052::CTestStep_MMF_CTLFRM_U_0052()

  3263 	/** Constructor

  3264 	*/

  3265 	{

  3266 	// store the name of this test case

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

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

  3269 	iTestStepName = _L("MM-MMF-CTLFRM-U-0052");

  3272 	}

  3274 TVerdict CTestStep_MMF_CTLFRM_U_0052::DoTestStepL( void )

  3275 /** As TSU_MMF_CTLFRM_U_0040

  3276  * Use case: N/A

  3277  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3278  */

  3279 	{

  3280 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3281 	__MM_HEAP_MARK;

  3283 	TVerdict verdict = EPass;

  3284 	_LIT8(KExpectedResult, "MardGetGainL Called");

  3286 	TMMFPrioritySettings settings;

  3287 	TInt error = KErrNone;

  3288 	RMMFController controller;

  3290 	settings.iPriority = 1;

  3291 	settings.iPref = EMdaPriorityPreferenceTime;

  3292 	settings.iState = EMMFStateIdle;

  3294 	TInt gain = 0;

  3296 	// Open a Custom Controller

  3297 	error = controller.Open(KTstControllerUid,settings);

  3298 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3300 	RMMFAudioRecordDeviceCustomCommands customCommands(controller);

  3302 	error = customCommands.GetGain(gain);

  3304 	//------------------------------------//

  3305 	// Getting Log from Custom Controller //

  3306 	//------------------------------------//

  3307 	if (!error)

  3308 		{

  3309 		INFO_PRINTF1(_L("Getting Log"));

  3311 		TBuf8<64> memFunctionText;

  3313 		TUid uid = {KMmfTestControllerUid};

  3314 		TMMFMessageDestination handleInfo(uid);

  3315 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3317 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3319 		TBuf<64> memFunctionText16;

  3320 		memFunctionText16.Copy(memFunctionText);

  3321 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  3323 		if (memFunctionText != KExpectedResult)

  3324 			{

  3325 			verdict = EFail;

  3326 			}

  3328 		}

  3329 	//------------------------------------//

  3331 	INFO_PRINTF2(_L("Gain: %d"),gain);

  3334 	if (error)

  3335 		{

  3336 		verdict = EFail;

  3337 		}

  3339 	INFO_PRINTF1(_L("Closing Controller"));

  3340 	controller.Close();

  3342 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3343 	__MM_HEAP_MARKEND;

  3345 	return verdict;

  3346 	}

  3348 //---------------------------------------------------------------

  3350 CTestStep_MMF_CTLFRM_U_0053::CTestStep_MMF_CTLFRM_U_0053()

  3351 	/** Constructor

  3352 	*/

  3353 	{

  3354 	// store the name of this test case

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

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

  3357 	iTestStepName = _L("MM-MMF-CTLFRM-U-0053");

  3360 	}

  3362 TVerdict CTestStep_MMF_CTLFRM_U_0053::DoTestStepL( void )

  3363 /** As TSU_MMF_CTLFRM_U_0040

  3364  * Use case: N/A

  3365  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3366  */

  3367 	{

  3368 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3369 	__MM_HEAP_MARK;

  3371 	TVerdict verdict = EPass;

  3372 	_LIT8(KExpectedResult, "MardSetBalanceL Called");

  3374 	TMMFPrioritySettings settings;

  3375 	TInt error = KErrNone;

  3376 	RMMFController controller;

  3378 	settings.iPriority = 1;

  3379 	settings.iPref = EMdaPriorityPreferenceTime;

  3380 	settings.iState = EMMFStateIdle;

  3382 	TInt balance = 5;

  3384 	// Open a Custom Controller

  3385 	error = controller.Open(KTstControllerUid,settings);

  3386 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3388 	RMMFAudioRecordDeviceCustomCommands customCommands(controller);

  3389 	error = customCommands.SetBalance(balance);

  3391 	//------------------------------------//

  3392 	// Getting Log from Custom Controller //

  3393 	//------------------------------------//

  3394 	if (!error)

  3395 		{

  3396 		INFO_PRINTF1(_L("Getting Log"));

  3398 		TBuf8<64> memFunctionText;

  3400 		TUid uid = {KMmfTestControllerUid};

  3401 		TMMFMessageDestination handleInfo(uid);

  3402 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3404 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3406 		TBuf<64> memFunctionText16;

  3407 		memFunctionText16.Copy(memFunctionText);

  3408 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  3410 		if (memFunctionText != KExpectedResult)

  3411 			{

  3412 			verdict = EFail;

  3413 			}

  3415 		}

  3416 	//------------------------------------//

  3418 	if (error)

  3419 		{

  3420 		verdict = EFail;

  3421 		}

  3423 	INFO_PRINTF1(_L("Closing Controller"));

  3424 	controller.Close();

  3426 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3427 	__MM_HEAP_MARKEND;

  3429 	return verdict;

  3430 	}

  3432 //---------------------------------------------------------------

  3434 CTestStep_MMF_CTLFRM_U_0054::CTestStep_MMF_CTLFRM_U_0054()

  3435 	/** Constructor

  3436 	*/

  3437 	{

  3438 	// store the name of this test case

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

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

  3441 	iTestStepName = _L("MM-MMF-CTLFRM-U-0054");

  3444 	}

  3446 TVerdict CTestStep_MMF_CTLFRM_U_0054::DoTestStepL( void )

  3447 /** As TSU_MMF_CTLFRM_U_0040

  3448  * Use case: N/A

  3449  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3450  */

  3451 	{

  3452 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3453 	__MM_HEAP_MARK;

  3455 	TVerdict verdict = EPass;

  3456 	_LIT8(KExpectedResult, "MardGetBalanceL Called");

  3458 	TMMFPrioritySettings settings;

  3459 	TInt error = KErrNone;

  3460 	RMMFController controller;

  3462 	settings.iPriority = 1;

  3463 	settings.iPref = EMdaPriorityPreferenceTime;

  3464 	settings.iState = EMMFStateIdle;

  3466 	TInt balance = 0;

  3468 	// Open a Custom Controller

  3469 	error = controller.Open(KTstControllerUid,settings);

  3470 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3472 	RMMFAudioRecordDeviceCustomCommands customCommands(controller);

  3473 	error = customCommands.GetBalance(balance);

  3475 	//------------------------------------//

  3476 	// Getting Log from Custom Controller //

  3477 	//------------------------------------//

  3478 	if (!error)

  3479 		{

  3480 		INFO_PRINTF1(_L("Getting Log"));

  3482 		TBuf8<64> memFunctionText;

  3484 		TUid uid = {KMmfTestControllerUid};

  3485 		TMMFMessageDestination handleInfo(uid);

  3486 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3488 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3490 		TBuf<64> memFunctionText16;

  3491 		memFunctionText16.Copy(memFunctionText);

  3492 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  3494 		if (memFunctionText != KExpectedResult)

  3495 			{

  3496 			verdict = EFail;

  3497 			}

  3499 		}

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

  3502 	INFO_PRINTF2(_L("Balance: %d"),balance);

  3504 	if (error)

  3505 		{

  3506 		verdict = EFail;

  3507 		}

  3509 	INFO_PRINTF1(_L("Closing Controller"));

  3510 	controller.Close();

  3512 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3513 	__MM_HEAP_MARKEND;

  3515 	return verdict;

  3516 	}

  3518 //---------------------------------------------------------------

  3520 CTestStep_MMF_CTLFRM_U_0060::CTestStep_MMF_CTLFRM_U_0060()

  3521 	/** Constructor

  3522 	*/

  3523 	{

  3524 	// store the name of this test case

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

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

  3527 	iTestStepName = _L("MM-MMF-CTLFRM-U-0060");

  3530 	}

  3532 TVerdict CTestStep_MMF_CTLFRM_U_0060::DoTestStepL( void )

  3533 /** As TSU_MMF_CTLFRM_U_0040

  3534  * Use case: N/A

  3535  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3536  */

  3537 	{

  3538 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3539 	__MM_HEAP_MARK;

  3541 	TVerdict verdict = EPass;

  3542 	_LIT8(KExpectedResult, "MapdSetPlaybackWindowL Called");

  3544 	TMMFPrioritySettings settings;

  3545 	TInt error = KErrNone;

  3546 	RMMFController controller;

  3548 	settings.iPriority = 1;

  3549 	settings.iPref = EMdaPriorityPreferenceTime;

  3550 	settings.iState = EMMFStateIdle;

  3552 	const TInt64 interval1 = 10;

  3553 	TTimeIntervalMicroSeconds start(interval1);

  3555 	const TInt64 interval2 = 25;

  3556 	TTimeIntervalMicroSeconds end(interval2);

  3558 	// Open a Custom Controller

  3559 	error = controller.Open(KTstControllerUid,settings);

  3560 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3562 	RMMFAudioPlayControllerCustomCommands customCommands(controller);

  3563 	error = customCommands.SetPlaybackWindow(start,end);

  3565 	//------------------------------------//

  3566 	// Getting Log from Custom Controller //

  3567 	//------------------------------------//

  3568 	if (!error)

  3569 		{

  3570 		INFO_PRINTF1(_L("Getting Log"));

  3572 		TBuf8<64> memFunctionText;

  3574 		TUid uid = {KMmfTestControllerUid};

  3575 		TMMFMessageDestination handleInfo(uid);

  3576 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3578 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3580 		TBuf<64> memFunctionText16;

  3581 		memFunctionText16.Copy(memFunctionText);

  3582 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  3584 		if (memFunctionText != KExpectedResult)

  3585 			{

  3586 			verdict = EFail;

  3587 			}

  3589 		}

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

  3592 	if (error)

  3593 		{

  3594 		verdict = EFail;

  3595 		}

  3597 	INFO_PRINTF1(_L("Closing Controller"));

  3598 	controller.Close();

  3600 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3601 	__MM_HEAP_MARKEND;

  3603 	return verdict;

  3604 	}

  3606 //---------------------------------------------------------------

  3608 CTestStep_MMF_CTLFRM_U_0061::CTestStep_MMF_CTLFRM_U_0061()

  3609 	/** Constructor

  3610 	*/

  3611 	{

  3612 	// store the name of this test case

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

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

  3615 	iTestStepName = _L("MM-MMF-CTLFRM-U-0061");

  3618 	}

  3620 TVerdict CTestStep_MMF_CTLFRM_U_0061::DoTestStepL( void )

  3621 /** As TSU_MMF_CTLFRM_U_0040

  3622  * Use case: N/A

  3623  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3624  */

  3625 	{

  3626 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3627 	__MM_HEAP_MARK;

  3629 	TVerdict verdict = EPass;

  3630 	_LIT8(KExpectedResult, "MapdDeletePlaybackWindowL Called");

  3632 	TMMFPrioritySettings settings;

  3633 	TInt error = KErrNone;

  3634 	RMMFController controller;

  3636 	settings.iPriority = 1;

  3637 	settings.iPref = EMdaPriorityPreferenceTime;

  3638 	settings.iState = EMMFStateIdle;

  3640 	// Open a Custom Controller

  3641 	error = controller.Open(KTstControllerUid,settings);

  3642 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3644 	RMMFAudioPlayControllerCustomCommands customCommands(controller);

  3645 	error = customCommands.DeletePlaybackWindow();

  3647 	//------------------------------------//

  3648 	// Getting Log from Custom Controller //

  3649 	//------------------------------------//

  3650 	if (!error)

  3651 		{

  3652 		INFO_PRINTF1(_L("Getting Log"));

  3654 		TBuf8<64> memFunctionText;

  3656 		TUid uid = {KMmfTestControllerUid};

  3657 		TMMFMessageDestination handleInfo(uid);

  3658 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3660 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3662 		TBuf<64> memFunctionText16;

  3663 		memFunctionText16.Copy(memFunctionText);

  3664 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  3666 		if (memFunctionText != KExpectedResult)

  3667 			{

  3668 			verdict = EFail;

  3669 			}

  3671 		}

  3672 	//------------------------------------//

  3674 	if (error)

  3675 		{

  3676 		verdict = EFail;

  3677 		}

  3679 	INFO_PRINTF1(_L("Closing Controller"));

  3680 	controller.Close();

  3682 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3683 	__MM_HEAP_MARKEND;

  3685 	return verdict;

  3686 	}

  3688 //---------------------------------------------------------------

  3691 CTestStep_MMF_CTLFRM_U_0070::CTestStep_MMF_CTLFRM_U_0070()

  3692 	/** Constructor

  3693 	*/

  3694 	{

  3695 	// store the name of this test case

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

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

  3698 	iTestStepName = _L("MM-MMF-CTLFRM-U-0070");

  3701 	}

  3703 TVerdict CTestStep_MMF_CTLFRM_U_0070::DoTestStepL( void )

  3704 /** As TSU_MMF_CTLFRM_U_0040

  3705  * Use case: N/A

  3706  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3707  */

  3708 	{

  3709 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3710 	__MM_HEAP_MARK;

  3712 	TVerdict verdict = EPass;

  3713 	_LIT8(KExpectedResult, "MarcGetRecordTimeAvailableL Called");

  3715 	TMMFPrioritySettings settings;

  3716 	TInt error = KErrNone;

  3717 	RMMFController controller;

  3719 	settings.iPriority = 1;

  3720 	settings.iPref = EMdaPriorityPreferenceTime;

  3721 	settings.iState = EMMFStateIdle;

  3723 	const TInt64 interval = 0;

  3724 	TTimeIntervalMicroSeconds recordTime(interval);

  3726 	// Open a Custom Controller

  3727 	error = controller.Open(KTstControllerUid,settings);

  3728 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3730 	RMMFAudioRecordControllerCustomCommands customCommands(controller);

  3731 	error = customCommands.GetRecordTimeAvailable(recordTime);

  3733 	INFO_PRINTF2(_L("Record Time Available %d"),recordTime.Int64());

  3735 	//------------------------------------//

  3736 	// Getting Log from Custom Controller //

  3737 	//------------------------------------//

  3738 	if (!error)

  3739 		{

  3740 		INFO_PRINTF1(_L("Getting Log"));

  3742 		TBuf8<64> memFunctionText;

  3744 		TUid uid = {KMmfTestControllerUid};

  3745 		TMMFMessageDestination handleInfo(uid);

  3746 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3748 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3750 		TBuf<64> memFunctionText16;

  3751 		memFunctionText16.Copy(memFunctionText);

  3752 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  3754 		if (memFunctionText != KExpectedResult)

  3755 			{

  3756 			verdict = EFail;

  3757 			}

  3759 		}

  3760 	//------------------------------------//

  3762 	if (error)

  3763 		{

  3764 		verdict = EFail;

  3765 		}

  3767 	INFO_PRINTF1(_L("Closing Controller"));

  3768 	controller.Close();

  3770 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3771 	__MM_HEAP_MARKEND;

  3773 	return verdict;

  3774 	}

  3776 //---------------------------------------------------------------

  3778 CTestStep_MMF_CTLFRM_U_0071::CTestStep_MMF_CTLFRM_U_0071()

  3779 	/** Constructor

  3780 	*/

  3781 	{

  3782 	// store the name of this test case

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

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

  3785 	iTestStepName = _L("MM-MMF-CTLFRM-U-0071");

  3788 	}

  3790 TVerdict CTestStep_MMF_CTLFRM_U_0071::DoTestStepL( void )

  3791 /** As TSU_MMF_CTLFRM_U_0040

  3792  * Use case: N/A

  3793  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3794  */

  3795 	{

  3796 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3797 	__MM_HEAP_MARK;

  3799 	TVerdict verdict = EPass;

  3800 	_LIT8(KExpectedResult, "MarcSetMaxDurationL Called");

  3802 	TMMFPrioritySettings settings;

  3803 	TInt error = KErrNone;

  3804 	RMMFController controller;

  3806 	settings.iPriority = 1;

  3807 	settings.iPref = EMdaPriorityPreferenceTime;

  3808 	settings.iState = EMMFStateIdle;

  3810 	const TInt64 interval = 25;

  3811 	TTimeIntervalMicroSeconds maxDuration(interval);

  3813 	// Open a Custom Controller

  3814 	error = controller.Open(KTstControllerUid,settings);

  3815 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3817 	RMMFAudioRecordControllerCustomCommands customCommands(controller);

  3818 	error = customCommands.SetMaxDuration(maxDuration);

  3820 	//------------------------------------//

  3821 	// Getting Log from Custom Controller //

  3822 	//------------------------------------//

  3823 	if (!error)

  3824 		{

  3825 		INFO_PRINTF1(_L("Getting Log"));

  3827 		TBuf8<64> memFunctionText;

  3829 		TUid uid = {KMmfTestControllerUid};

  3830 		TMMFMessageDestination handleInfo(uid);

  3831 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3833 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3835 		TBuf<64> memFunctionText16;

  3836 		memFunctionText16.Copy(memFunctionText);

  3837 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  3839 		if (memFunctionText != KExpectedResult)

  3840 			{

  3841 			verdict = EFail;

  3842 			}

  3844 		}

  3845 	//------------------------------------//

  3847 	if (error)

  3848 		{

  3849 		verdict = EFail;

  3850 		}

  3852 	INFO_PRINTF1(_L("Closing Controller"));

  3853 	controller.Close();

  3855 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3856 	__MM_HEAP_MARKEND;

  3858 	return verdict;

  3859 	}

  3862 //---------------------------------------------------------------

  3864 CTestStep_MMF_CTLFRM_U_0072::CTestStep_MMF_CTLFRM_U_0072()

  3865 	/** Constructor

  3866 	*/

  3867 	{

  3868 	// store the name of this test case

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

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

  3871 	iTestStepName = _L("MM-MMF-CTLFRM-U-0072");

  3874 	}

  3876 TVerdict CTestStep_MMF_CTLFRM_U_0072::DoTestStepL( void )

  3877 /** As TSU_MMF_CTLFRM_U_0040

  3878  * Use case: N/A

  3879  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3880  */

  3881 	{

  3882 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3883 	__MM_HEAP_MARK;

  3885 	TVerdict verdict = EPass;

  3886 	_LIT8(KExpectedResult, "MarcSetMaxFileSizeL Called");

  3888 	TMMFPrioritySettings settings;

  3889 	TInt error = KErrNone;

  3890 	RMMFController controller;

  3892 	settings.iPriority = 1;

  3893 	settings.iPref = EMdaPriorityPreferenceTime;

  3894 	settings.iState = EMMFStateIdle;

  3896 	const TInt fileSize = 10;

  3898 	// Open a Custom Controller

  3899 	error = controller.Open(KTstControllerUid,settings);

  3900 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3902 	RMMFAudioRecordControllerCustomCommands customCommands(controller);

  3903 	error = customCommands.SetMaxFileSize(fileSize);

  3905 	//------------------------------------//

  3906 	// Getting Log from Custom Controller //

  3907 	//------------------------------------//

  3908 	if (!error)

  3909 		{

  3910 		INFO_PRINTF1(_L("Getting Log"));

  3912 		TBuf8<64> memFunctionText;

  3914 		TUid uid = {KMmfTestControllerUid};

  3915 		TMMFMessageDestination handleInfo(uid);

  3916 		TMMFMessageDestinationPckg messageDest(handleInfo);

  3918 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  3920 		TBuf<64> memFunctionText16;

  3921 		memFunctionText16.Copy(memFunctionText);

  3922 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  3924 		if (memFunctionText != KExpectedResult)

  3925 			{

  3926 			verdict = EFail;

  3927 			}

  3929 		}

  3930 	//------------------------------------//

  3933 	if (error)

  3934 		{

  3935 		verdict = EFail;

  3936 		}

  3938 	INFO_PRINTF1(_L("Closing Controller"));

  3939 	controller.Close();

  3941 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  3942 	__MM_HEAP_MARKEND;

  3944 	return verdict;

  3945 	}

  3948 //---------------------------------------------------------------

  3950 CTestStep_MMF_CTLFRM_U_0073::CTestStep_MMF_CTLFRM_U_0073()

  3951 	/** Constructor

  3952 	*/

  3953 	{

  3954 	// store the name of this test case

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

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

  3957 	iTestStepName = _L("MM-MMF-CTLFRM-U-0073");

  3960 	}

  3962 TVerdict CTestStep_MMF_CTLFRM_U_0073::DoTestStepL( void )

  3963 /** As TSU_MMF_CTLFRM_U_0040

  3964  * Use case: N/A

  3965  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  3966  */

  3967 	{

  3968 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  3969 	__MM_HEAP_MARK;

  3971 	TVerdict verdict = EPass;

  3972 	_LIT8(KExpectedResult, "MarcCropL Called");

  3974 	TMMFPrioritySettings settings;

  3975 	TInt error = KErrNone;

  3976 	RMMFController controller;

  3978 	settings.iPriority = 1;

  3979 	settings.iPref = EMdaPriorityPreferenceTime;

  3980 	settings.iState = EMMFStateIdle;

  3982 	// Open a Custom Controller

  3983 	error = controller.Open(KTstControllerUid,settings);

  3984 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  3986 	RMMFAudioRecordControllerCustomCommands customCommands(controller);

  3987 	error = customCommands.Crop(ETrue);

  3989 	//------------------------------------//

  3990 	// Getting Log from Custom Controller //

  3991 	//------------------------------------//

  3992 	if (!error)

  3993 		{

  3994 		INFO_PRINTF1(_L("Getting Log"));

  3996 		TBuf8<64> memFunctionText;

  3998 		TUid uid = {KMmfTestControllerUid};

  3999 		TMMFMessageDestination handleInfo(uid);

  4000 		TMMFMessageDestinationPckg messageDest(handleInfo);

  4002 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  4004 		TBuf<64> memFunctionText16;

  4005 		memFunctionText16.Copy(memFunctionText);

  4006 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  4009 		if (memFunctionText != KExpectedResult)

  4010 			{

  4011 			verdict = EFail;

  4012 			}

  4014 		}

  4015 	//------------------------------------//

  4017 	if (error)

  4018 		{

  4019 		verdict = EFail;

  4020 		}

  4022 	INFO_PRINTF1(_L("Closing Controller"));

  4023 	controller.Close();

  4025 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4026 	__MM_HEAP_MARKEND;

  4028 	return verdict;

  4029 	}

  4032 //---------------------------------------------------------------

  4034 CTestStep_MMF_CTLFRM_U_0074::CTestStep_MMF_CTLFRM_U_0074()

  4035 	/** Constructor

  4036 	*/

  4037 	{

  4038 	// store the name of this test case

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

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

  4041 	iTestStepName = _L("MM-MMF-CTLFRM-U-0074");

  4044 	}

  4046 TVerdict CTestStep_MMF_CTLFRM_U_0074::DoTestStepL( void )

  4047 /** As TSU_MMF_CTLFRM_U_0040

  4048  * Use case: N/A

  4049  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4050  */

  4051 	{

  4052 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4053 	__MM_HEAP_MARK;

  4055 	TVerdict verdict = EPass;

  4056 	_LIT8(KExpectedResult, "MarcAddMetaDataEntryL Called");

  4058 	TMMFPrioritySettings settings;

  4059 	TInt error = KErrNone;

  4060 	RMMFController controller;

  4062 	CMMFMetaDataEntry* metaEntry = CMMFMetaDataEntry::NewL();

  4063 	CleanupStack::PushL(metaEntry);

  4065 	settings.iPriority = 1;

  4066 	settings.iPref = EMdaPriorityPreferenceTime;

  4067 	settings.iState = EMMFStateIdle;

  4069 	// Open a Custom Controller

  4070 	error = controller.Open(KTstControllerUid,settings);

  4071 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4073 	RMMFAudioRecordControllerCustomCommands customCommands(controller);

  4074 	customCommands.AddMetaDataEntryL(*metaEntry);

  4076 	//------------------------------------//

  4077 	// Getting Log from Custom Controller //

  4078 	//------------------------------------//

  4079 	if (!error)

  4080 		{

  4081 		INFO_PRINTF1(_L("Getting Log"));

  4083 		TBuf8<64> memFunctionText;

  4085 		TUid uid = {KMmfTestControllerUid};

  4086 		TMMFMessageDestination handleInfo(uid);

  4087 		TMMFMessageDestinationPckg messageDest(handleInfo);

  4089 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  4091 		TBuf<64> memFunctionText16;

  4092 		memFunctionText16.Copy(memFunctionText);

  4093 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  4095 		if (memFunctionText != KExpectedResult)

  4096 			{

  4097 			verdict = EFail;

  4098 			}

  4100 		}

  4101 	//------------------------------------//

  4103 	if (error)

  4104 		{

  4105 		verdict = EFail;

  4106 		}

  4108 	INFO_PRINTF1(_L("Closing Controller"));

  4109 	controller.Close();

  4111 	CleanupStack::PopAndDestroy();

  4113 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4114 	__MM_HEAP_MARKEND;

  4116 	return verdict;

  4117 	}

  4120 //---------------------------------------------------------------

  4123 CTestStep_MMF_CTLFRM_U_0075::CTestStep_MMF_CTLFRM_U_0075()

  4124 	/** Constructor

  4125 	*/

  4126 	{

  4127 	// store the name of this test case

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

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

  4130 	iTestStepName = _L("MM-MMF-CTLFRM-U-0075");

  4133 	}

  4135 TVerdict CTestStep_MMF_CTLFRM_U_0075::DoTestStepL( void )

  4136 /** As TSU_MMF_CTLFRM_U_0040

  4137  * Use case: N/A

  4138  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4139  */

  4140 	{

  4141 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4142 	__MM_HEAP_MARK;

  4144 	TVerdict verdict = EPass;

  4145 	_LIT8(KExpectedResult, "MarcRemoveMetaDataEntryL Called");

  4147 	TMMFPrioritySettings settings;

  4148 	TInt error = KErrNone;

  4149 	RMMFController controller;

  4151 	TInt index = 1;

  4153 	settings.iPriority = 1;

  4154 	settings.iPref = EMdaPriorityPreferenceTime;

  4155 	settings.iState = EMMFStateIdle;

  4157 	// Open a Custom Controller

  4158 	error = controller.Open(KTstControllerUid,settings);

  4159 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4161 	RMMFAudioRecordControllerCustomCommands customCommands(controller);

  4162 	error = customCommands.RemoveMetaDataEntry(index);

  4164 	//------------------------------------//

  4165 	// Getting Log from Custom Controller //

  4166 	//------------------------------------//

  4167 	if (!error)

  4168 		{

  4169 		INFO_PRINTF1(_L("Getting Log"));

  4171 		TBuf8<64> memFunctionText;

  4173 		TUid uid = {KMmfTestControllerUid};

  4174 		TMMFMessageDestination handleInfo(uid);

  4175 		TMMFMessageDestinationPckg messageDest(handleInfo);

  4177 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  4179 		TBuf<64> memFunctionText16;

  4180 		memFunctionText16.Copy(memFunctionText);

  4181 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  4183 		if (memFunctionText != KExpectedResult)

  4184 			{

  4185 			verdict = EFail;

  4186 			}

  4188 		}

  4189 	//------------------------------------//

  4191 	if (error)

  4192 		{

  4193 		verdict = EFail;

  4194 		}

  4196 	INFO_PRINTF1(_L("Closing Controller"));

  4197 	controller.Close();

  4199 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4200 	__MM_HEAP_MARKEND;

  4202 	return verdict;

  4203 	}

  4206 //---------------------------------------------------------------

  4208 CTestStep_MMF_CTLFRM_U_0076::CTestStep_MMF_CTLFRM_U_0076()

  4209 	/** Constructor

  4210 	*/

  4211 	{

  4212 	// store the name of this test case

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

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

  4215 	iTestStepName = _L("MM-MMF-CTLFRM-U-0076");

  4218 	}

  4220 TVerdict CTestStep_MMF_CTLFRM_U_0076::DoTestStepL( void )

  4221 /** As TSU_MMF_CTLFRM_U_0040

  4222  * Use case: N/A

  4223  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4224  */

  4225 	{

  4226 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4227 	__MM_HEAP_MARK;

  4229 	TVerdict verdict = EPass;

  4230 	_LIT8(KExpectedResult, "MarcReplaceMetaDataEntryL Called");

  4232 	TMMFPrioritySettings settings;

  4233 	TInt error = KErrNone;

  4234 	RMMFController controller;

  4236 	const TInt index = 1;

  4237 	CMMFMetaDataEntry* metaEntry = CMMFMetaDataEntry::NewL();

  4238 	CleanupStack::PushL(metaEntry);

  4240 	settings.iPriority = 1;

  4241 	settings.iPref = EMdaPriorityPreferenceTime;

  4242 	settings.iState = EMMFStateIdle;

  4244 	// Open a Custom Controller

  4245 	error = controller.Open(KTstControllerUid,settings);

  4246 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4248 	RMMFAudioRecordControllerCustomCommands customCommands(controller);

  4249 	customCommands.ReplaceMetaDataEntryL(index, *metaEntry);

  4251 	//------------------------------------//

  4252 	// Getting Log from Custom Controller //

  4253 	//------------------------------------//

  4254 	if (!error)

  4255 		{

  4256 		INFO_PRINTF1(_L("Getting Log"));

  4258 		TBuf8<64> memFunctionText;

  4260 		TUid uid = {KMmfTestControllerUid};

  4261 		TMMFMessageDestination handleInfo(uid);

  4262 		TMMFMessageDestinationPckg messageDest(handleInfo);

  4264 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  4266 		TBuf<64> memFunctionText16;

  4267 		memFunctionText16.Copy(memFunctionText);

  4268 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  4270 		if (memFunctionText != KExpectedResult)

  4271 			{

  4272 			verdict = EFail;

  4273 			}

  4275 		}

  4276 	//------------------------------------//

  4278 	if (error)

  4279 		{

  4280 		verdict = EFail;

  4281 		}

  4283 	INFO_PRINTF1(_L("Closing Controller"));

  4284 	controller.Close();

  4286 	CleanupStack::PopAndDestroy();

  4288 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4289 	__MM_HEAP_MARKEND;

  4291 	return verdict;

  4292 	}

  4295 //---------------------------------------------------------------

  4297 CTestStep_MMF_CTLFRM_U_0080::CTestStep_MMF_CTLFRM_U_0080()

  4298 	/** Constructor

  4299 	*/

  4300 	{

  4301 	// store the name of this test case

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

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

  4304 	iTestStepName = _L("MM-MMF-CTLFRM-U-0080");

  4307 	}

  4309 TVerdict CTestStep_MMF_CTLFRM_U_0080::DoTestStepL( void )

  4310 /** As TSU_MMF_CTLFRM_U_0040

  4311  * Use case: N/A

  4312  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4313  */

  4314 	{

  4315 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4316 	__MM_HEAP_MARK;

  4318 	TVerdict verdict = EPass;

  4320 	TMMFPrioritySettings settings;

  4321 	TInt error = KErrNone;

  4322 	RMMFController controller;

  4324 	const TUint sample = 1;

  4326 	settings.iPriority = 1;

  4327 	settings.iPref = EMdaPriorityPreferenceTime;

  4328 	settings.iState = EMMFStateIdle;

  4330 	// Open a Custom Controller

  4331 	error = controller.Open(KTstControllerUid,settings);

  4332 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4334 	RMMFAudioControllerCustomCommands customCommands(controller);

  4335 	error = customCommands.SetSourceSampleRate(sample);

  4336 	if (error)

  4337 		{

  4338 		verdict = EFail;

  4339 		}

  4341 	INFO_PRINTF1(_L("Closing Controller"));

  4342 	controller.Close();

  4344 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4345 	__MM_HEAP_MARKEND;

  4347 	return verdict;

  4348 	}

  4351 //---------------------------------------------------------------

  4353 CTestStep_MMF_CTLFRM_U_0081::CTestStep_MMF_CTLFRM_U_0081()

  4354 	/** Constructor

  4355 	*/

  4356 	{

  4357 	// store the name of this test case

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

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

  4360 	iTestStepName = _L("MM-MMF-CTLFRM-U-0081");

  4363 	}

  4365 TVerdict CTestStep_MMF_CTLFRM_U_0081::DoTestStepL( void )

  4366 /** As TSU_MMF_CTLFRM_U_0040

  4367  * Use case: N/A

  4368  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4369  */

  4370 	{

  4371 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4372 	__MM_HEAP_MARK;

  4374 	TVerdict verdict = EPass;

  4376 	TMMFPrioritySettings settings;

  4377 	TInt error = KErrNone;

  4378 	RMMFController controller;

  4380 	const TUint numChannels = 1;

  4382 	settings.iPriority = 1;

  4383 	settings.iPref = EMdaPriorityPreferenceTime;

  4384 	settings.iState = EMMFStateIdle;

  4386 	// Open a Custom Controller

  4387 	error = controller.Open(KTstControllerUid,settings);

  4388 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4390 	RMMFAudioControllerCustomCommands customCommands(controller);

  4391 	error = customCommands.SetSourceNumChannels(numChannels);

  4393 	if (error)

  4394 		{

  4395 		verdict = EFail;

  4396 		}

  4398 	INFO_PRINTF1(_L("Closing Controller"));

  4399 	controller.Close();

  4401 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4402 	__MM_HEAP_MARKEND;

  4404 	return verdict;

  4405 	}

  4408 //---------------------------------------------------------------

  4411 CTestStep_MMF_CTLFRM_U_0082::CTestStep_MMF_CTLFRM_U_0082()

  4412 	/** Constructor

  4413 	*/

  4414 	{

  4415 	// store the name of this test case

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

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

  4418 	iTestStepName = _L("MM-MMF-CTLFRM-U-0082");

  4421 	}

  4423 TVerdict CTestStep_MMF_CTLFRM_U_0082::DoTestStepL( void )

  4424 /** As TSU_MMF_CTLFRM_U_0040

  4425  * Use case: N/A

  4426  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4427  */

  4428 	{

  4429 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4430 	__MM_HEAP_MARK;

  4432 	TVerdict verdict = EPass;

  4434 	TMMFPrioritySettings settings;

  4435 	TInt error = KErrNone;

  4436 	RMMFController controller;

  4438 	TUid uid = {0x12345678};

  4440 	settings.iPriority = 1;

  4441 	settings.iPref = EMdaPriorityPreferenceTime;

  4442 	settings.iState = EMMFStateIdle;

  4444 	// Open a Custom Controller

  4445 	error = controller.Open(KTstControllerUid,settings);

  4446 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4448 	RMMFAudioControllerCustomCommands customCommands(controller);

  4449 	error = customCommands.SetSourceFormat(uid);

  4451 	if (error)

  4452 		{

  4453 		verdict = EFail;

  4454 		}

  4456 	INFO_PRINTF1(_L("Closing Controller"));

  4457 	controller.Close();

  4459 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4460 	__MM_HEAP_MARKEND;

  4462 	return verdict;

  4463 	}

  4466 //---------------------------------------------------------------

  4468 CTestStep_MMF_CTLFRM_U_0083::CTestStep_MMF_CTLFRM_U_0083()

  4469 	/** Constructor

  4470 	*/

  4471 	{

  4472 	// store the name of this test case

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

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

  4475 	iTestStepName = _L("MM-MMF-CTLFRM-U-0083");

  4478 	}

  4480 TVerdict CTestStep_MMF_CTLFRM_U_0083::DoTestStepL( void )

  4481 /** As TSU_MMF_CTLFRM_U_0040

  4482  * Use case: N/A

  4483  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4484  */

  4485 	{

  4486 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4487 	__MM_HEAP_MARK;

  4489 	TVerdict verdict = EPass;

  4491 	TMMFPrioritySettings settings;

  4492 	TInt error = KErrNone;

  4493 	RMMFController controller;

  4495 	TUint sampleRate = 5;

  4497 	settings.iPriority = 1;

  4498 	settings.iPref = EMdaPriorityPreferenceTime;

  4499 	settings.iState = EMMFStateIdle;

  4501 	// Open a Custom Controller

  4502 	error = controller.Open(KTstControllerUid,settings);

  4503 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4505 	RMMFAudioControllerCustomCommands customCommands(controller);

  4506 	error = customCommands.SetSinkSampleRate(sampleRate);

  4508 	if (error)

  4509 		{

  4510 		verdict = EFail;

  4511 		}

  4513 	INFO_PRINTF1(_L("Closing Controller"));

  4514 	controller.Close();

  4516 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4517 	__MM_HEAP_MARKEND;

  4519 	return verdict;

  4520 	}

  4523 //---------------------------------------------------------------

  4525 CTestStep_MMF_CTLFRM_U_0084::CTestStep_MMF_CTLFRM_U_0084()

  4526 	/** Constructor

  4527 	*/

  4528 	{

  4529 	// store the name of this test case

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

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

  4532 	iTestStepName = _L("MM-MMF-CTLFRM-U-0084");

  4535 	}

  4537 TVerdict CTestStep_MMF_CTLFRM_U_0084::DoTestStepL( void )

  4538 /** As TSU_MMF_CTLFRM_U_0040

  4539  * Use case: N/A

  4540  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4541  */

  4542 	{

  4543 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4544 	__MM_HEAP_MARK;

  4546 	TVerdict verdict = EPass;

  4548 	TMMFPrioritySettings settings;

  4549 	TInt error = KErrNone;

  4550 	RMMFController controller;

  4552 	TUint numChannels = 1;

  4554 	settings.iPriority = 1;

  4555 	settings.iPref = EMdaPriorityPreferenceTime;

  4556 	settings.iState = EMMFStateIdle;

  4558 	// Open a Custom Controller

  4559 	error = controller.Open(KTstControllerUid,settings);

  4560 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4562 	RMMFAudioControllerCustomCommands customCommands(controller);

  4563 	error = customCommands.SetSinkNumChannels(numChannels);

  4565 	if (error)

  4566 		{

  4567 		verdict = EFail;

  4568 		}

  4570 	INFO_PRINTF1(_L("Closing Controller"));

  4571 	controller.Close();

  4573 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4574 	__MM_HEAP_MARKEND;

  4576 	return verdict;

  4577 	}

  4580 //---------------------------------------------------------------

  4582 CTestStep_MMF_CTLFRM_U_0085::CTestStep_MMF_CTLFRM_U_0085()

  4583 	/** Constructor

  4584 	*/

  4585 	{

  4586 	// store the name of this test case

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

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

  4589 	iTestStepName = _L("MM-MMF-CTLFRM-U-0085");

  4592 	}

  4594 TVerdict CTestStep_MMF_CTLFRM_U_0085::DoTestStepL( void )

  4595 /** As TSU_MMF_CTLFRM_U_0040

  4596  * Use case: N/A

  4597  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4598  */

  4599 	{

  4600 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4601 	__MM_HEAP_MARK;

  4603 	TVerdict verdict = EPass;

  4605 	TMMFPrioritySettings settings;

  4606 	TInt error = KErrNone;

  4607 	RMMFController controller;

  4609 	TUid sinkUid = {0x12345679};

  4610 	CMMFMetaDataEntry* metaEntry = CMMFMetaDataEntry::NewL();

  4611 	CleanupStack::PushL(metaEntry);

  4613 	settings.iPriority = 1;

  4614 	settings.iPref = EMdaPriorityPreferenceTime;

  4615 	settings.iState = EMMFStateIdle;

  4617 	// Open a Custom Controller

  4618 	error = controller.Open(KTstControllerUid,settings);

  4619 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4621 	RMMFAudioControllerCustomCommands customCommands(controller);

  4622 	error = customCommands.SetSinkFormat(sinkUid);

  4624 	if (error)

  4625 		{

  4626 		verdict = EFail;

  4627 		}

  4629 	INFO_PRINTF1(_L("Closing Controller"));

  4630 	controller.Close();

  4632 	CleanupStack::PopAndDestroy(1);

  4634 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4635 	__MM_HEAP_MARKEND;

  4637 	return verdict;

  4638 	}

  4641 //---------------------------------------------------------------

  4644 CTestStep_MMF_CTLFRM_U_0086::CTestStep_MMF_CTLFRM_U_0086()

  4645 	/** Constructor

  4646 	*/

  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-CTLFRM-U-0086");

  4654 	}

  4656 TVerdict CTestStep_MMF_CTLFRM_U_0086::DoTestStepL( void )

  4657 /** As TSU_MMF_CTLFRM_U_0040

  4658  * Use case: N/A

  4659  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4660  */

  4661 	{

  4662 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4663 	__MM_HEAP_MARK;

  4665 	TVerdict verdict = EPass;

  4667 	TMMFPrioritySettings settings;

  4668 	TInt error = KErrNone;

  4669 	RMMFController controller;

  4671 	TFourCC sourceFourCC(' ','P','1','6');

  4672 	TFourCC sinkFourCC(' ','P','1','6');

  4674 	settings.iPriority = 1;

  4675 	settings.iPref = EMdaPriorityPreferenceTime;

  4676 	settings.iState = EMMFStateIdle;

  4678 	// Open a Custom Controller

  4679 	error = controller.Open(KTstControllerUid,settings);

  4680 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4682 	RMMFAudioControllerCustomCommands customCommands(controller);

  4683 	error = customCommands.SetCodec(sourceFourCC, sinkFourCC);

  4685 	if (error)

  4686 		{

  4687 		verdict = EFail;

  4688 		}

  4690 	INFO_PRINTF1(_L("Closing Controller"));

  4691 	controller.Close();

  4694 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4695 	__MM_HEAP_MARKEND;

  4697 	return verdict;

  4698 	}

  4701 //---------------------------------------------------------------

  4705 CTestStep_MMF_CTLFRM_U_0100::CTestStep_MMF_CTLFRM_U_0100()

  4706 	/** Constructor

  4707 	*/

  4708 	{

  4709 	// store the name of this test case

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

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

  4712 	iTestStepName = _L("MM-MMF-CTLFRM-U-0100");

  4715 	}

  4717 TVerdict CTestStep_MMF_CTLFRM_U_0100::DoTestStepL( void )

  4718 /** This test is to add and remove multiple Sources and Sinks and ensure this is

  4719  *  carried out correctly.

  4721  * Use case: N/A

  4722  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4723  */

  4724 	{

  4725 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4726 	__MM_HEAP_MARK;

  4728 	TVerdict verdict = EPass;

  4730 	TMMFPrioritySettings settings;

  4731 	TInt error = KErrNone;

  4732 	RMMFController controller;

  4734 	settings.iPriority = 1;

  4735 	settings.iPref = EMdaPriorityPreferenceTime;

  4736 	settings.iState = EMMFStateIdle;

  4738 	const TDesC8& initData = KInitData;

  4740 	CArrayFixFlat<TMMFMessageDestination>* sinkHandles = new (ELeave) CArrayFixFlat<TMMFMessageDestination>(6);

  4741 	CleanupStack::PushL(sinkHandles);

  4742 	CArrayFixFlat<TMMFMessageDestination>* sourceHandles = new (ELeave) CArrayFixFlat<TMMFMessageDestination>(3);

  4743 	CleanupStack::PushL(sourceHandles);

  4746 	// Open a Custom Controller

  4747 	error = controller.Open(KTstControllerUid,settings);

  4748 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4750 		// Add Sink

  4751 	if (!error)

  4752 		{

  4753 		INFO_PRINTF1(_L("API TEST: Calling AddDataSink"));

  4754 		TMMFMessageDestination& sinkHandle = sinkHandles->ExtendL();

  4755 		error = controller.AddDataSink(KTestDataSinkUid, initData, sinkHandle);   // index = 1

  4757 		TMMFMessageDestination& sinkHandle2= sinkHandles->ExtendL();

  4758 		error = controller.AddDataSink(KTestDataSinkBUid, initData, sinkHandle2);  // index = 2

  4760 		TMMFMessageDestination& sinkHandle3 = sinkHandles->ExtendL();

  4761 		error = controller.AddDataSink(KTestDataSinkUid, initData, sinkHandle3);   // index = 3

  4763 		TMMFMessageDestination& sinkHandle4 = sinkHandles->ExtendL();

  4764 		error = controller.AddDataSink(KTestDataSinkBUid, initData, sinkHandle4);  // index = 4

  4766 		TMMFMessageDestination& sourceHandle = sourceHandles->ExtendL();

  4767 		error = controller.AddDataSource(KTestDataSourceUid, initData, sourceHandle);  // index = 1

  4769 		TMMFMessageDestination& sourceHandle2 = sourceHandles->ExtendL();

  4770 		error = controller.AddDataSource(KTestDataSourceUid, initData, sourceHandle2);  // index = 2

  4772 		TMMFMessageDestination& sourceHandle3 = sourceHandles->ExtendL();

  4773 		error = controller.AddDataSource(KTestDataSourceBUid, initData, sourceHandle3); // index = 3

  4775 		TMMFMessageDestination& sinkHandle5 = sinkHandles->ExtendL();

  4776 		error = controller.AddDataSink(KTestDataSinkUid, initData, sinkHandle5); // index = 5

  4778 		TMMFMessageDestination& sinkHandle6 = sinkHandles->ExtendL();

  4779 		error = controller.AddDataSink(KTestDataSinkUid, initData, sinkHandle6); // index = 6

  4780 		}

  4782 	if (!error)

  4783 		{

  4784 		// Remove two Sinks and a Source

  4785 		error = controller.RemoveDataSink((*sinkHandles)[2]);

  4787 		error = controller.RemoveDataSource((*sourceHandles)[2]);

  4789 		error = controller.RemoveDataSink((*sinkHandles)[5]);

  4791 		}

  4793 	if (error)

  4794 		{

  4795 		verdict = EFail;

  4796 		}

  4798 	INFO_PRINTF1(_L("Closing Controller"));

  4799 	controller.Close();

  4801 	CleanupStack::PopAndDestroy(2);

  4803 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4804 	__MM_HEAP_MARKEND;

  4806 	return verdict;

  4807 	}

  4810 //---------------------------------------------------------------

  4813 CTestStep_MMF_CTLFRM_U_0110::CTestStep_MMF_CTLFRM_U_0110()

  4814 	/** Constructor

  4815 	*/

  4816 	{

  4817 	// store the name of this test case

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

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

  4820 	iTestStepName = _L("MM-MMF-CTLFRM-U-0110");

  4822 	}

  4824 TVerdict CTestStep_MMF_CTLFRM_U_0110::DoTestStepL( void )

  4825 /** Verfiy CMMFDescriptorBuffer creation and deletion using default buffer size

  4826  * Use case: N/A

  4827  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4828  */

  4829 	{

  4830 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4831 	__MM_HEAP_MARK;

  4833 	TVerdict verdict = EPass;

  4835 	TMMFPrioritySettings settings;

  4836 	TInt error = KErrNone;

  4837 	RMMFController controller;

  4839 	settings.iPriority = 1;

  4840 	settings.iPref = EMdaPriorityPreferenceTime;

  4841 	settings.iState = EMMFStateIdle;

  4843 	// Open a Custom Controller

  4845 	INFO_PRINTF1(_L("Controller Instantiation Fail"));

  4846 	__UHEAP_FAILNEXT(1); // Make the Controller Instantiation fail

  4847 	__MM_HEAP_MARK;

  4848 	TRAP(error, controller.Open(KTstControllerUid,settings));

  4849 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4851 	__MM_HEAP_MARKEND;

  4853 	if (error)

  4854 		{

  4855 		verdict = EFail;

  4856 		}

  4858 	INFO_PRINTF1(_L("Closing Controller"));

  4859 	controller.Close();

  4861 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4862 	__MM_HEAP_MARKEND;

  4864 	return verdict;

  4865 	}

  4868 //---------------------------------------------------------------

  4870 CTestStep_MMF_CTLFRM_U_0111::CTestStep_MMF_CTLFRM_U_0111()

  4871 	/** Constructor

  4872 	*/

  4873 	{

  4874 	// store the name of this test case

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

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

  4877 	iTestStepName = _L("MM-MMF-CTLFRM-U-0111");

  4880 	}

  4882 TVerdict CTestStep_MMF_CTLFRM_U_0111::DoTestStepL( void )

  4883 /** Verfiy CMMFDescriptorBuffer creation and deletion using default buffer size

  4884  * Use case: N/A

  4885  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4886  */

  4887 	{

  4888 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4889 	__MM_HEAP_MARK;

  4891 	TVerdict verdict = EPass;

  4892 	_LIT8(KExpectedResult, "AddDataSourceL Called");

  4894 	TMMFPrioritySettings settings;

  4895 	TInt error = KErrNone;

  4896 	RMMFController controller;

  4898 	settings.iPriority = 1;

  4899 	settings.iPref = EMdaPriorityPreferenceTime;

  4900 	settings.iState = EMMFStateIdle;

  4902 	error = controller.Open(KTstControllerUid,settings);

  4903 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4905 	const TDesC8& initData = KInitData;

  4907 	// Add Source

  4908 	INFO_PRINTF1(_L("Attempting to add a Source and a Sink to Controller"));

  4909 	if (!error)

  4910 		{

  4911 		INFO_PRINTF1(_L("API TEST: Calling AddDataSource"));

  4912 		__UHEAP_FAILNEXT(1);

  4913 		error = controller.AddDataSource(KTestDataSourceUid, initData);

  4914 		}

  4916 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  4918 	//------------------------------------//

  4919 	// Getting Log from Custom Controller //

  4920 	//------------------------------------//

  4921 	if (!error)

  4922 		{

  4923 		INFO_PRINTF1(_L("Getting Log"));

  4925 		TBuf8<64> memFunctionText;

  4928 		TUid uid = {KMmfTestControllerUid};

  4929 		TMMFMessageDestination handleInfo(uid);

  4930 		TMMFMessageDestinationPckg messageDest(handleInfo);

  4932 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  4934 		TBuf<64> memFunctionText16;

  4935 		memFunctionText16.Copy(memFunctionText);

  4936 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  4938 		if (memFunctionText != KExpectedResult)

  4939 			{

  4940 			verdict = EFail;

  4941 			}

  4943 		}

  4944 	//------------------------------------//

  4947 	INFO_PRINTF1(_L("Closing Controller"));

  4948 	controller.Close();

  4950 	if (error)

  4951 		{

  4952 		verdict = EFail;

  4953 		}

  4955 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  4956 	__MM_HEAP_MARKEND;

  4958 	return verdict;

  4959 	}

  4962 //---------------------------------------------------------------

  4964 CTestStep_MMF_CTLFRM_U_0112::CTestStep_MMF_CTLFRM_U_0112()

  4965 	/** Constructor

  4966 	*/

  4967 	{

  4968 	// store the name of this test case

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

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

  4971 	iTestStepName = _L("MM-MMF-CTLFRM-U-0112");

  4974 	}

  4976 TVerdict CTestStep_MMF_CTLFRM_U_0112::DoTestStepL( void )

  4977 /** Verfiy CMMFDescriptorBuffer creation and deletion using default buffer size

  4978  * Use case: N/A

  4979  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  4980  */

  4981 	{

  4982 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  4983 	__MM_HEAP_MARK;

  4985 	TVerdict verdict = EPass;

  4986 	_LIT8(KExpectedResult, "AddDataSinkL Called");

  4988 	TMMFPrioritySettings settings;

  4989 	TInt error = KErrNone;

  4990 	RMMFController controller;

  4992 	settings.iPriority = 1;

  4993 	settings.iPref = EMdaPriorityPreferenceTime;

  4994 	settings.iState = EMMFStateIdle;

  4996 	error = controller.Open(KTstControllerUid,settings);

  4997 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  4999 	const TDesC8& initData = KInitData;

  5001 	// Add Sink

  5002 	if (!error)

  5003 		{

  5004 		INFO_PRINTF1(_L("API TEST: Calling AddDataSink"));

  5005 		__UHEAP_FAILNEXT(1);

  5006 		error = controller.AddDataSink(KTestDataSinkUid, initData);

  5007 		}

  5010 	INFO_PRINTF2(_L("Controller Status: %d"), error);

  5012 	//------------------------------------//

  5013 	// Getting Log from Custom Controller //

  5014 	//------------------------------------//

  5015 	if (!error)

  5016 		{

  5017 		INFO_PRINTF1(_L("Getting Log"));

  5019 		TBuf8<64> memFunctionText;

  5021 		TUid uid = {KMmfTestControllerUid};

  5022 		TMMFMessageDestination handleInfo(uid);

  5023 		TMMFMessageDestinationPckg messageDest(handleInfo);

  5025 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  5027 		TBuf<64> memFunctionText16;

  5028 		memFunctionText16.Copy(memFunctionText);

  5029 		INFO_PRINTF2(_L("Log: %S"),&memFunctionText16);

  5031 		if (memFunctionText != KExpectedResult)

  5032 			{

  5033 			verdict = EFail;

  5034 			}

  5036 		}

  5037 	//------------------------------------//

  5039 	INFO_PRINTF1(_L("Closing Controller"));

  5040 	controller.Close();

  5042 	if (error)

  5043 		{

  5044 		verdict = EFail;

  5045 		}

  5047 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5048 	__MM_HEAP_MARKEND;

  5050 	return verdict;

  5051 	}

  5054 //---------------------------------------------------------------

  5056 CTestStep_MMF_CTLFRM_U_0120::CTestStep_MMF_CTLFRM_U_0120()

  5057 	/** Constructor

  5058 	*/

  5059 	{

  5060 	// store the name of this test case

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

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

  5063 	iTestStepName = _L("MM-MMF-CTLFRM-U-0120");

  5066 	}

  5068 TVerdict CTestStep_MMF_CTLFRM_U_0120::DoTestStepL( void )

  5069 /** Instantiate a CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParameters

  5070  *  set the parameters appropiately (See API Method Calls and Parameters) to obtain

  5071  *  controller Implementation Uid's in a CMMFControllerImplementationInformation Array to

  5072  *  open a controller. Open the controller, check for errors and close the controller.

  5073  *  (Test CMMFFormatSelectionParameters API).

  5075  * Use case: N/A

  5076  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5077  */

  5078 	{

  5079 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5080 	__MM_HEAP_MARK;

  5082 	TVerdict verdict = EPass;

  5084 	TMMFPrioritySettings settings;

  5085 	TInt error = KErrNone;

  5086 	RMMFController controller1;

  5088 	settings.iPriority = 1;

  5089 	settings.iPref = EMdaPriorityPreferenceTime;

  5090 	settings.iState = EMMFStateIdle;

  5092 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5093 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5095 	// Set the format match data

  5097 	//---------------------//

  5098 	// Method being Tested //

  5099 	//---------------------//

  5100 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  5101 	//---------------------//

  5103 	// Set the controller plugin play format match data

  5104 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5106 	// Get Controllers

  5107 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5108 	CleanupResetAndDestroyPushL(controllers);

  5109 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5111 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5112 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5114 	INFO_PRINTF1(_L("Closing Controller"));

  5115 	controller1.Close();

  5117 	if (error)

  5118 		{

  5119 		verdict = EFail;

  5120 		}

  5122 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5123 	__MM_HEAP_MARKEND;

  5125 	return verdict;

  5126 	}

  5129 //---------------------------------------------------------------

  5131 CTestStep_MMF_CTLFRM_U_0121::CTestStep_MMF_CTLFRM_U_0121()

  5132 	/** Constructor

  5133 	*/

  5134 	{

  5135 	// store the name of this test case

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

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

  5138 	iTestStepName = _L("MM-MMF-CTLFRM-U-0121");

  5141 	}

  5143 TVerdict CTestStep_MMF_CTLFRM_U_0121::DoTestStepL( void )

  5144 /** As TSU_MMF_CTLFRM_U_0120

  5145  * Use case: N/A

  5146  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5147  */

  5148 	{

  5149 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5150 	__MM_HEAP_MARK;

  5152 	TVerdict verdict = EPass;

  5154 	TMMFPrioritySettings settings;

  5155 	TInt error = KErrNone;

  5156 	RMMFController controller1;

  5158 	settings.iPriority = 1;

  5159 	settings.iPref = EMdaPriorityPreferenceTime;

  5160 	settings.iState = EMMFStateIdle;

  5162 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5163 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5165 	//---------------------//

  5166 	// Method being Tested //

  5167 	//---------------------//

  5168 	_LIT8(KMimeData, "audio/mbeg");

  5169 	fSelect->SetMatchToMimeTypeL(KMimeData);

  5170 	//--------------------//

  5172 	// Set the controller plugin play format match data

  5173 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5175 	cSelect->SetPreferredSupplierL(_L("Symbian"), CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  5177 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5178 	CleanupResetAndDestroyPushL(controllers);

  5179 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5181 	// Check Array Size here

  5182 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5183 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5185 	INFO_PRINTF1(_L("Closing Controller"));

  5186 	controller1.Close();

  5188 	if (error)

  5189 		{

  5190 		verdict = EFail;

  5191 		}

  5193 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5194 	__MM_HEAP_MARKEND;

  5196 	return verdict;

  5197 	}

  5200 //---------------------------------------------------------------

  5202 CTestStep_MMF_CTLFRM_U_0122::CTestStep_MMF_CTLFRM_U_0122()

  5203 	/** Constructor

  5204 	*/

  5205 	{

  5206 	// store the name of this test case

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

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

  5209 	iTestStepName = _L("MM-MMF-CTLFRM-U-0122");

  5212 	}

  5214 TVerdict CTestStep_MMF_CTLFRM_U_0122::DoTestStepL( void )

  5215 /** As TSU_MMF_CTLFRM_U_0120

  5216  * Use case: N/A

  5217  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5218  */

  5219 	{

  5220 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5221 	__MM_HEAP_MARK;

  5223 	TVerdict verdict = EPass;

  5225 	TMMFPrioritySettings settings;

  5226 	TInt error = KErrNone;

  5227 	RMMFController controller1;

  5229 	settings.iPriority = 1;

  5230 	settings.iPref = EMdaPriorityPreferenceTime;

  5231 	settings.iState = EMMFStateIdle;

  5233 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5234 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5236 	//---------------------//

  5237 	// Method being Tested //

  5238 	//---------------------//

  5239 	_LIT8(KHeaderData, "RIFF????PAVE");

  5240 	fSelect->SetMatchToHeaderDataL(KHeaderData);

  5241 	//--------------------//

  5243 	// Set the controller plugin play format match data

  5244 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5246 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5247 	CleanupResetAndDestroyPushL(controllers);

  5248 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5249 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5250 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5251 	controller1.Close();

  5253 	if (error)

  5254 		{

  5255 		verdict = EFail;

  5256 		}

  5258 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5259 	__MM_HEAP_MARKEND;

  5261 	return verdict;

  5262 	}

  5265 //---------------------------------------------------------------

  5267 CTestStep_MMF_CTLFRM_U_0123::CTestStep_MMF_CTLFRM_U_0123()

  5268 	/** Constructor

  5269 	*/

  5270 	{

  5271 	// store the name of this test case

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

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

  5274 	iTestStepName = _L("MM-MMF-CTLFRM-U-0123");

  5277 	}

  5279 TVerdict CTestStep_MMF_CTLFRM_U_0123::DoTestStepL( void )

  5280 /** As TSU_MMF_CTLFRM_U_0120

  5281  * Use case: N/A

  5282  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5283  */

  5284 	{

  5285 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5286 	__MM_HEAP_MARK;

  5288 	TVerdict verdict = EPass;

  5290 	TMMFPrioritySettings settings;

  5291 	TInt error = KErrNone;

  5292 	RMMFController controller1;

  5294 	settings.iPriority = 1;

  5295 	settings.iPref = EMdaPriorityPreferenceTime;

  5296 	settings.iState = EMMFStateIdle;

  5298 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5299 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5302 	_LIT8(KHeaderData, "RIFF????PAVE");

  5303 	fSelect->SetMatchToHeaderDataL(KHeaderData);

  5306 	//---------------------//

  5307 	// Method being Tested //

  5308 	//---------------------//

  5309 	fSelect->MatchData();

  5310 	//---------------------//

  5312 	// Set the controller plugin play format match data

  5313 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5315 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5316 	CleanupResetAndDestroyPushL(controllers);

  5317 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5318 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5319 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5320 	controller1.Close();

  5322 	if (error)

  5323 		{

  5324 		verdict = EFail;

  5325 		}

  5327 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5328 	__MM_HEAP_MARKEND;

  5330 	return verdict;

  5331 	}

  5334 //---------------------------------------------------------------

  5336 CTestStep_MMF_CTLFRM_U_0124::CTestStep_MMF_CTLFRM_U_0124()

  5337 	/** Constructor

  5338 	*/

  5339 	{

  5340 	// store the name of this test case

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

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

  5343 	iTestStepName = _L("MM-MMF-CTLFRM-U-0124");

  5346 	}

  5348 TVerdict CTestStep_MMF_CTLFRM_U_0124::DoTestStepL( void )

  5349 /**As TSU_MMF_CTLFRM_U_0120

  5350  * Use case: N/A

  5351  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5352  */

  5353 	{

  5354 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5355 	__MM_HEAP_MARK;

  5357 	TVerdict verdict = EPass;

  5359 	TMMFPrioritySettings settings;

  5360 	TInt error = KErrNone;

  5361 	RMMFController controller1;

  5363 	settings.iPriority = 1;

  5364 	settings.iPref = EMdaPriorityPreferenceTime;

  5365 	settings.iState = EMMFStateIdle;

  5367 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5368 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5370 	_LIT8(KHeaderData, "RIFF????PAVE");

  5371 	fSelect->SetMatchToHeaderDataL(KHeaderData);

  5373 	//---------------------//

  5374 	// Method being Tested //

  5375 	//---------------------//

  5376 //	CMMFFormatSelectionParameters::TMatchDataType dataType;	//EABI warning removal

  5377 //	dataType = fSelect->MatchDataType();

  5378 	//--------------------//

  5380 	// Set the controller plugin play format match data

  5381 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5383 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5384 	CleanupResetAndDestroyPushL(controllers);

  5385 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5386 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5387 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5388 	controller1.Close();

  5390 	if (error)

  5391 		{

  5392 		verdict = EFail;

  5393 		}

  5395 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5396 	__MM_HEAP_MARKEND;

  5398 	return verdict;

  5399 	}

  5401 //---------------------------------------------------------------

  5405 CTestStep_MMF_CTLFRM_U_0130::CTestStep_MMF_CTLFRM_U_0130()

  5406 	/** Constructor

  5407 	*/

  5408 	{

  5409 	// store the name of this test case

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

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

  5412 	iTestStepName = _L("MM-MMF-CTLFRM-U-0130");

  5415 	}

  5417 TVerdict CTestStep_MMF_CTLFRM_U_0130::DoTestStepL( void )

  5418 /** Instantiate a CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParameters

  5419  *  set the parameters appropiately (See API Method Calls and Parameters) to obtain

  5420  *  controller Implementation Uid's in a CMMFControllerImplementationInformation Array to

  5421  *  open a controller. Check the details obtained to open the controller are correct. Open

  5422  *  the controller, check for errors and close the controller.

  5423  *  (Test CMMFControllerPluginSelectionParameters API).

  5425  * Use case: N/A

  5426  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5427  */

  5428 	{

  5429 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5430 	__MM_HEAP_MARK;

  5432 	TVerdict verdict = EPass;

  5434 	TMMFPrioritySettings settings;

  5435 	TInt error = KErrNone;

  5436 	RMMFController controller1;

  5438 	settings.iPriority = 1;

  5439 	settings.iPref = EMdaPriorityPreferenceTime;

  5440 	settings.iState = EMMFStateIdle;

  5442 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5443 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5445 	//_LIT8(KHeaderData, "RIFF????PAVE");

  5446 	//fSelect->SetMatchToHeaderDataL(KHeaderData);

  5447 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  5449 	//---------------------//

  5450 	// Method being Tested //

  5451 	//---------------------//

  5452 	// Set the controller plugin play format match data

  5453 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5454 	//--------------------//

  5456 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5457 	CleanupResetAndDestroyPushL(controllers);

  5458 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5459 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5461 	TUid controllerUid;

  5462 	controllerUid = controllers[0]->Uid();

  5464 	if (controllerUid == KTstControllerUid)

  5465 		{

  5466 		verdict = EPass;

  5467 		}

  5468 	else

  5469 		{

  5470 		verdict = EFail;

  5471 		}

  5473 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5474 	controller1.Close();

  5476 	if (error)

  5477 		{

  5478 		verdict = EFail;

  5479 		}

  5481 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5482 	__MM_HEAP_MARKEND;

  5484 	return verdict;

  5485 	}

  5488 //---------------------------------------------------------------

  5491 CTestStep_MMF_CTLFRM_U_0131::CTestStep_MMF_CTLFRM_U_0131()

  5492 	/** Constructor

  5493 	*/

  5494 	{

  5495 	// store the name of this test case

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

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

  5498 	iTestStepName = _L("MM-MMF-CTLFRM-U-0131");

  5501 	}

  5503 TVerdict CTestStep_MMF_CTLFRM_U_0131::DoTestStepL( void )

  5504 /** As TSU_MMF_CTLFRM_U_0130

  5506  * Use case: N/A

  5507  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5508  */

  5509 	{

  5510 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5511 	__MM_HEAP_MARK;

  5513 	TVerdict verdict = EPass;

  5515 	TMMFPrioritySettings settings;

  5516 	TInt error = KErrNone;

  5517 	RMMFController controller1;

  5519 	settings.iPriority = 1;

  5520 	settings.iPref = EMdaPriorityPreferenceTime;

  5521 	settings.iState = EMMFStateIdle;

  5524 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5525 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5527 	fSelect->SetMatchToFileNameL(_L("test.ai"));

  5529 	//---------------------//

  5530 	// Method being Tested //

  5531 	//---------------------//

  5532 	// Set the controller plugin play format match data

  5533 	cSelect->SetRequiredRecordFormatSupportL(*fSelect);

  5534 	//--------------------//

  5536 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5537 	CleanupResetAndDestroyPushL(controllers);

  5538 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5539 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5541 	TUid controllerUid;

  5542 	controllerUid = controllers[0]->Uid();

  5544 	if (controllerUid == KTstControllerUid)

  5545 		{

  5546 		verdict = EPass;

  5547 		}

  5548 	else

  5549 		{

  5550 		verdict = EFail;

  5551 		}

  5553 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5554 	controller1.Close();

  5556 	if (error)

  5557 		{

  5558 		verdict = EFail;

  5559 		}

  5561 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5562 	__MM_HEAP_MARKEND;

  5564 	return verdict;

  5565 	}

  5568 //---------------------------------------------------------------

  5571 CTestStep_MMF_CTLFRM_U_0140::CTestStep_MMF_CTLFRM_U_0140()

  5572 	/** Constructor

  5573 	*/

  5574 	{

  5575 	// store the name of this test case

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

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

  5578 	iTestStepName = _L("MM-MMF-CTLFRM-U-0140");

  5581 	}

  5583 TVerdict CTestStep_MMF_CTLFRM_U_0140::DoTestStepL( void )

  5584 /** Instantiate a CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParameters

  5585  *  set the parameters appropiately (See API Method Calls and Parameters) to obtain

  5586  *  controller Implementation Uid's in a CMMFControllerImplementationInformation Array to

  5587  *  open a controller. Check the details obtained to open the controller are correct. Open

  5588  *  the controller, check for errors and close the controller.

  5589  *  (Test CMMFPluginImplementationInformation API)

  5591  * Use case: N/A

  5592  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5593  */

  5594 	{

  5595 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5596 	__MM_HEAP_MARK;

  5598 	TVerdict verdict = EPass;

  5600 	TMMFPrioritySettings settings;

  5601 	TInt error = KErrNone;

  5602 	RMMFController controller1;

  5604 	settings.iPriority = 1;

  5605 	settings.iPref = EMdaPriorityPreferenceTime;

  5606 	settings.iState = EMMFStateIdle;

  5608 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5609 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5611 	// Set the format match data

  5613 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  5615 	// Set the controller plugin play format match data

  5616 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5618 	// Get Controllers

  5619 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5620 	CleanupResetAndDestroyPushL(controllers);

  5621 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5623 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5625 	//---------------------//

  5626 	// Method being Tested //

  5627 	//---------------------//

  5628 	TUid controllerUid;

  5629 	controllerUid = controllers[0]->Uid();

  5631 	if (controllerUid == KTstControllerUid)

  5632 		{

  5633 		verdict = EPass;

  5634 		}

  5635 	else

  5636 		{

  5637 		verdict = EFail;

  5638 		}

  5639 	//--------------------//

  5642 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5643 	controller1.Close();

  5645 	if (error)

  5646 		{

  5647 		verdict = EFail;

  5648 		}

  5650 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5651 	__MM_HEAP_MARKEND;

  5653 	return verdict;

  5654 	}

  5657 //---------------------------------------------------------------

  5660 CTestStep_MMF_CTLFRM_U_0141::CTestStep_MMF_CTLFRM_U_0141()

  5661 	/** Constructor

  5662 	*/

  5663 	{

  5664 	// store the name of this test case

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

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

  5667 	iTestStepName = _L("MM-MMF-CTLFRM-U-0141");

  5670 	}

  5672 TVerdict CTestStep_MMF_CTLFRM_U_0141::DoTestStepL( void )

  5673 /** As TSU_MMF_CTLFRM_U_0140

  5675  * Use case: N/A

  5676  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5677  */

  5678 	{

  5679 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5680 	__MM_HEAP_MARK;

  5682 	TVerdict verdict = EPass;

  5684 	_LIT(KExpectedName,"CMMFTestController");

  5686 	TMMFPrioritySettings settings;

  5687 	TInt error = KErrNone;

  5688 	RMMFController controller1;

  5690 	settings.iPriority = 1;

  5691 	settings.iPref = EMdaPriorityPreferenceTime;

  5692 	settings.iState = EMMFStateIdle;

  5695 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5696 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5698 	// Set the format match data

  5700 	//---------------------//

  5701 	// Method being Tested //

  5702 	//---------------------//

  5703 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  5704 	//---------------------//

  5706 	// Set the controller plugin play format match data

  5707 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5709 	// Get Controllers

  5710 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5711 	CleanupResetAndDestroyPushL(controllers);

  5712 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5714 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5716 	//---------------------//

  5717 	// Method being Tested //

  5718 	//---------------------//

  5719 	TPtrC controllerName;

  5720 	controllerName.Set(controllers[0]->DisplayName());

  5721 	INFO_PRINTF2(_L("Controller Name: %S"),&controllerName);

  5723 	if (controllerName == KExpectedName)

  5724 		{

  5725 		verdict = EPass;

  5726 		}

  5727 	else

  5728 		{

  5729 		verdict = EFail;

  5730 		}

  5731 	//--------------------//

  5733 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5734 	controller1.Close();

  5736 	if (error)

  5737 		{

  5738 		verdict = EFail;

  5739 		}

  5741 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5742 	__MM_HEAP_MARKEND;

  5744 	return verdict;

  5745 	}

  5748 //---------------------------------------------------------------

  5751 CTestStep_MMF_CTLFRM_U_0142::CTestStep_MMF_CTLFRM_U_0142()

  5752 	/** Constructor

  5753 	*/

  5754 	{

  5755 	// store the name of this test case

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

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

  5758 	iTestStepName = _L("MM-MMF-CTLFRM-U-0142");

  5761 	}

  5763 TVerdict CTestStep_MMF_CTLFRM_U_0142::DoTestStepL( void )

  5764 /** As TSU_MMF_CTLFRM_U_0140

  5766  * Use case: N/A

  5767  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5768  */

  5769 	{

  5770 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5771 	__MM_HEAP_MARK;

  5773 	TVerdict verdict = EPass;

  5775 	_LIT(KExpectedSupplier, "TSU_MMF_CTLFRM");

  5777 	TMMFPrioritySettings settings;

  5778 	TInt error = KErrNone;

  5779 	RMMFController controller1;

  5781 	settings.iPriority = 1;

  5782 	settings.iPref = EMdaPriorityPreferenceTime;

  5783 	settings.iState = EMMFStateIdle;

  5785 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5786 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5788 	// Set the format match data

  5790 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  5792 	// Set the controller plugin play format match data

  5793 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5795 	// Get Controllers

  5796 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5797 	CleanupResetAndDestroyPushL(controllers);

  5798 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5800 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5802 	//---------------------//

  5803 	// Method being Tested //

  5804 	//---------------------//

  5805 	TPtrC supplier;

  5807 	supplier.Set(controllers[0]->Supplier());

  5809 	INFO_PRINTF2(_L("Controller Name: %S"),&supplier);

  5810 	TPtrC expectedSupplierPtrC;

  5811 	expectedSupplierPtrC.Set(KExpectedSupplier);

  5813 	if (*supplier.Ptr() == *expectedSupplierPtrC.Ptr())

  5814 		{

  5815 		verdict = EPass;

  5816 		}

  5817 	else

  5818 		{

  5819 		verdict = EFail;

  5820 		}

  5821 	//--------------------//

  5823 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5824 	controller1.Close();

  5826 	if (error)

  5827 		{

  5828 		verdict = EFail;

  5829 		}

  5831 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5832 	__MM_HEAP_MARKEND;

  5834 	return verdict;

  5835 	}

  5838 //---------------------------------------------------------------

  5840 CTestStep_MMF_CTLFRM_U_0143::CTestStep_MMF_CTLFRM_U_0143()

  5841 	/** Constructor

  5842 	*/

  5843 	{

  5844 	// store the name of this test case

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

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

  5847 	iTestStepName = _L("MM-MMF-CTLFRM-U-0143");

  5850 	}

  5852 TVerdict CTestStep_MMF_CTLFRM_U_0143::DoTestStepL( void )

  5853 /** As TSU_MMF_CTLFRM_U_0140

  5855  * Use case: N/A

  5856  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5857  */

  5858 	{

  5859 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5860 	__MM_HEAP_MARK;

  5862 	TVerdict verdict = EPass;

  5864 	// Expected result

  5865 	TInt expectVersionNo = 3;

  5867 	TMMFPrioritySettings settings;

  5868 	TInt error = KErrNone;

  5869 	RMMFController controller1;

  5871 	settings.iPriority = 1;

  5872 	settings.iPref = EMdaPriorityPreferenceTime;

  5873 	settings.iState = EMMFStateIdle;

  5876 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5877 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5879 	// Set the format match data

  5881 	//---------------------//

  5882 	// Method being Tested //

  5883 	//---------------------//

  5884 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  5885 	//---------------------//

  5887 	// Set the controller plugin play format match data

  5888 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5890 	// Get Controllers

  5891 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5892 	CleanupResetAndDestroyPushL(controllers);

  5893 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5895 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // instantiate the controller

  5898 	//---------------------//

  5899 	// Method being Tested //

  5900 	//---------------------//

  5901 	TInt versionNo;

  5902 	versionNo = controllers[0]->Version();

  5903 	INFO_PRINTF2(_L("Controller Name:%d"),versionNo);

  5905 	if (expectVersionNo != versionNo)

  5906 		{

  5907 		verdict = EFail;

  5908 		}

  5909 	//--------------------//

  5912 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5913 	controller1.Close();

  5915 	if (error)

  5916 		{

  5917 		verdict = EFail;

  5918 		}

  5920 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  5921 	__MM_HEAP_MARKEND;

  5923 	return verdict;

  5924 	}

  5927 //---------------------------------------------------------------

  5930 CTestStep_MMF_CTLFRM_U_0144::CTestStep_MMF_CTLFRM_U_0144()

  5931 	/** Constructor

  5932 	*/

  5933 	{

  5934 	// store the name of this test case

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

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

  5937 	iTestStepName = _L("MM-MMF-CTLFRM-U-0144");

  5940 	}

  5942 TVerdict CTestStep_MMF_CTLFRM_U_0144::DoTestStepL( void )

  5943 /** As TSU_MMF_CTLFRM_U_0140

  5945  * Use case: N/A

  5946  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  5947  */

  5948 	{

  5949 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  5950 	__MM_HEAP_MARK;

  5952 	TVerdict verdict = EPass;

  5954 	TMMFPrioritySettings settings;

  5955 	TInt error = KErrNone;

  5956 	RMMFController controller1;

  5958 	settings.iPriority = 1;

  5959 	settings.iPref = EMdaPriorityPreferenceTime;

  5960 	settings.iState = EMMFStateIdle;

  5962 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  5963 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  5965 	// Set the format match data

  5967 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  5969 	// Set the controller plugin play format match data

  5970 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  5972 	// Get Controllers

  5973 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  5974 	CleanupResetAndDestroyPushL(controllers);

  5975 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  5977 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  5979 	//---------------------//

  5980 	// Method being Tested //

  5981 	//---------------------//

  5982 	const RArray<TUid>& mediaIds = controllers[0]->SupportedMediaIds();

  5984 	TUid controllerUid = mediaIds[0];

  5985 	if (controllerUid == KExpectedMediaIDUid140)

  5986 		{

  5987 		verdict = EPass;

  5988 		}

  5989 	else

  5990 		{

  5991 		verdict = EFail;

  5992 		}

  5993 	//--------------------//

  5995 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  5996 	controller1.Close();

  5998 	if (error)

  5999 		{

  6000 		verdict = EFail;

  6001 		}

  6003 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6004 	__MM_HEAP_MARKEND;

  6006 	return verdict;

  6007 	}

  6009 //---------------------------------------------------------------

  6012 CTestStep_MMF_CTLFRM_U_0145::CTestStep_MMF_CTLFRM_U_0145()

  6013 	/** Constructor

  6014 	*/

  6015 	{

  6016 	// store the name of this test case

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

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

  6019 	iTestStepName = _L("MM-MMF-CTLFRM-U-0145");

  6022 	}

  6024 TVerdict CTestStep_MMF_CTLFRM_U_0145::DoTestStepL( void )

  6025 /** As TSU_MMF_CTLFRM_U_0140

  6027  * Use case: N/A

  6028  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6029  */

  6030 	{

  6031 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6032 	__MM_HEAP_MARK;

  6034 	TVerdict verdict = EPass;

  6036 	TMMFPrioritySettings settings;

  6037 	TInt error = KErrNone;

  6038 	RMMFController controller1;

  6040 	settings.iPriority = 1;

  6041 	settings.iPref = EMdaPriorityPreferenceTime;

  6042 	settings.iState = EMMFStateIdle;

  6044 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6045 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6047 	// Set the format match data

  6049 	//---------------------//

  6050 	// Method being Tested //

  6051 	//---------------------//

  6052 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  6053 	//---------------------//

  6055 	// Set the controller plugin play format match data

  6056 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  6058 	// Get Controllers

  6059 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6060 	CleanupResetAndDestroyPushL(controllers);

  6061 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  6063 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6065 	//---------------------//

  6066 	// Method being Tested //

  6067 	//---------------------//

  6068 	TBool supplierSupported = controllers[0]->SupportsSupplier(_L("TSU_MMF_CTLFRM"));

  6070 	if (!supplierSupported)

  6071 		{

  6072 		verdict = EFail;

  6073 		}

  6074 	//--------------------//

  6076 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6077 	controller1.Close();

  6079 	if (error)

  6080 		{

  6081 		verdict = EFail;

  6082 		}

  6084 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6085 	__MM_HEAP_MARKEND;

  6087 	return verdict;

  6088 	}

  6090 //---------------------------------------------------------------

  6093 CTestStep_MMF_CTLFRM_U_0146::CTestStep_MMF_CTLFRM_U_0146()

  6094 	/** Constructor

  6095 	*/

  6096 	{

  6097 	// store the name of this test case

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

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

  6100 	iTestStepName = _L("MM-MMF-CTLFRM-U-0146");

  6103 	}

  6105 TVerdict CTestStep_MMF_CTLFRM_U_0146::DoTestStepL( void )

  6106 /** As TSU_MMF_CTLFRM_U_0140

  6107  * Use case: N/A

  6108  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6109  */

  6110 	{

  6111 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6112 	__MM_HEAP_MARK;

  6114 	TVerdict verdict = EPass;

  6116 	TMMFPrioritySettings settings;

  6117 	TInt error = KErrNone;

  6118 	RMMFController controller1;

  6120 	settings.iPriority = 1;

  6121 	settings.iPref = EMdaPriorityPreferenceTime;

  6122 	settings.iState = EMMFStateIdle;

  6124 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6125 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6127 	// Set the format match data

  6129 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  6131 	// Set the controller plugin play format match data

  6132 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  6134 	// Get Controllers

  6135 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6136 	CleanupResetAndDestroyPushL(controllers);

  6137 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  6139 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6141 	//---------------------//

  6142 	// Method being Tested //

  6143 	//---------------------//

  6144 	TBool mediaSupported = controllers[0]->SupportsMediaId(KExpectedMediaIDUid140);

  6146 	if (!mediaSupported)

  6147 		{

  6148 		verdict = EFail;

  6149 		}

  6150 	//--------------------//

  6152 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6153 	controller1.Close();

  6155 	if (error)

  6156 		{

  6157 		verdict = EFail;

  6158 		}

  6160 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6161 	__MM_HEAP_MARKEND;

  6163 	return verdict;

  6164 	}

  6166 //---------------------------------------------------------------

  6168 CTestStep_MMF_CTLFRM_U_0150::CTestStep_MMF_CTLFRM_U_0150()

  6169 	/** Constructor

  6170 	*/

  6171 	{

  6172 	// store the name of this test case

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

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

  6175 	iTestStepName = _L("MM-MMF-CTLFRM-U-0150");

  6178 	}

  6180 TVerdict CTestStep_MMF_CTLFRM_U_0150::DoTestStepL( void )

  6181 /** Instanciate a CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParameters

  6182  *  set the parameters appropiately (See API Method Calls and Parameters) to obtain

  6183  *  controller Implementation Uid's in a CMMFControllerImplementationInformation Array to

  6184  *  open a controller. Check the details obtained to open the controller are correct. Open

  6185  *  the controller, check for errors and close the controller.

  6186  *  (Test CMMFControllerImplementationInformation API)

  6188  * Use case: N/A

  6189  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6190  */

  6191 	{

  6192 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6193 	__MM_HEAP_MARK;

  6195 	TVerdict verdict = EPass;

  6197 	TMMFPrioritySettings settings;

  6198 	TInt error = KErrNone;

  6199 	RMMFController controller1;

  6201 	settings.iPriority = 1;

  6202 	settings.iPref = EMdaPriorityPreferenceTime;

  6203 	settings.iState = EMMFStateIdle;

  6205 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6206 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6208 	// Set the format match data

  6210 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  6212 	// Set the controller plugin play format match data

  6213 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  6215 	// Get Controllers

  6216 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6217 	CleanupResetAndDestroyPushL(controllers);

  6218 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  6220 	//---------------------//

  6221 	// Method being Tested //

  6222 	//---------------------//

  6223 	RMMFFormatImplInfoArray controllersPlayFormats = controllers[0]->PlayFormats();

  6224 	INFO_PRINTF2(_L("Number of Play Formats: %d"),controllersPlayFormats.Count());

  6226 	TUid formatUid = controllersPlayFormats[0]->Uid();

  6228 	if (formatUid == KMmfUidFormatPAVReadUid ||

  6229 		formatUid == KMmfUidFormatFAWReadUid ||

  6230 		formatUid == KMmfUidFormatAIReadUid  ||

  6231 		formatUid == KMmfUidFormatMBEGReadUid)

  6232 		{

  6233 		verdict = EPass;

  6234 		}

  6235 	else

  6236 		{

  6237 		verdict = EFail;

  6238 		}

  6239 	//--------------------//

  6241 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6243 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6244 	controller1.Close();

  6246 	if (error)

  6247 		{

  6248 		verdict = EFail;

  6249 		}

  6251 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6252 	__MM_HEAP_MARKEND;

  6254 	return verdict;

  6255 	}

  6257 //---------------------------------------------------------------

  6260 CTestStep_MMF_CTLFRM_U_0151::CTestStep_MMF_CTLFRM_U_0151()

  6261 	/** Constructor

  6262 	*/

  6263 	{

  6264 	// store the name of this test case

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

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

  6267 	iTestStepName = _L("MM-MMF-CTLFRM-U-0151");

  6270 	}

  6272 TVerdict CTestStep_MMF_CTLFRM_U_0151::DoTestStepL( void )

  6273 /** As TSU_MMF_CTLFRM_U_0150

  6274  * Use case: N/A

  6275  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6276  */

  6277 	{

  6278 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6279 	__MM_HEAP_MARK;

  6281 	TVerdict verdict = EPass;

  6283 	TMMFPrioritySettings settings;

  6284 	TInt error = KErrNone;

  6285 	RMMFController controller1;

  6287 	settings.iPriority = 1;

  6288 	settings.iPref = EMdaPriorityPreferenceTime;

  6289 	settings.iState = EMMFStateIdle;

  6291 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6292 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6294 	// Set the format match data

  6295 	fSelect->SetMatchToFileNameL(_L("test.ai"));

  6297 	// Set the controller plugin play format match data

  6298 	cSelect->SetRequiredRecordFormatSupportL(*fSelect);

  6300 	// Get Controllers

  6301 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6302 	CleanupResetAndDestroyPushL(controllers);

  6303 	cSelect->ListImplementationsL(controllers); // Populates the array with all the suitable controllers

  6305 	//---------------------//

  6306 	// Method being Tested //

  6307 	//---------------------//

  6308 	RMMFFormatImplInfoArray controllersRecordFormats = controllers[0]->RecordFormats();

  6309 	INFO_PRINTF2(_L("Number of Record Formats: %d"),controllersRecordFormats.Count());

  6311 	TUid formatUid = controllersRecordFormats[0]->Uid();

  6313 	if (formatUid == KMmfUidFormatPAVWriteUid  ||

  6314 		formatUid == KMmfUidFormatFAWWriteUid ||

  6315 		formatUid == KMmfUidFormatAIWriteUid)

  6316 		{

  6317 		verdict = EPass;

  6318 		}

  6319 	else

  6320 		{

  6321 		verdict = EFail;

  6322 		}

  6323 	//--------------------//

  6325 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6327 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6328 	controller1.Close();

  6330 	if (error)

  6331 		{

  6332 		verdict = EFail;

  6333 		}

  6335 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6336 	__MM_HEAP_MARKEND;

  6338 	return verdict;

  6339 	}

  6341 //------------------------------------------------------------

  6343 CTestStep_MMF_CTLFRM_U_0197::CTestStep_MMF_CTLFRM_U_0197()

  6344 	/** Constructor

  6345 	*/

  6346 	{

  6347 	// store the name of this test case

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

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

  6350 	iTestStepName = _L("MM-MMF-CTLFRM-U-0197");

  6353 	}

  6355 TVerdict CTestStep_MMF_CTLFRM_U_0197::DoTestStepL( void )

  6356 /** As TSU_MMF_CTLFRM_U_0140

  6358  * Use case: N/A

  6359  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6360  */

  6361 	{

  6363 	_LIT8(KExpectedText, "rtsp");

  6364 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6365 	__MM_HEAP_MARK;

  6367 	TVerdict verdict = EPass;

  6369 	TMMFPrioritySettings settings;

  6370 	TInt error = KErrNone;

  6371 	RMMFController controller1;

  6373 	settings.iPriority = 1;

  6374 	settings.iPref = EMdaPriorityPreferenceTime;

  6375 	settings.iState = EMMFStateIdle;

  6377 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6378 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6380 	// Set the format match data

  6381 	fSelect->SetMatchToUriSupportL(_L("rtsp://www.symbian.com/first/test/directory/test.rm"));

  6383 	// Set the controller plugin play format match data

  6384 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  6386 	// Get Controllers

  6387 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6388 	CleanupResetAndDestroyPushL(controllers);

  6389 	cSelect->ListImplementationsL(controllers);  // Populates the array with all the suitable controllers

  6391 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6393 	//---------------------//

  6394 	// Method being Tested //

  6395 	//---------------------//

  6396 	const CDesC8Array* uriSchemes = &controllers[0]->SupportedUriSchemes();

  6398 	if (uriSchemes->Count() > 0)

  6399     	{

  6400 		TPtrC8 ptrC;

  6401 		ptrC.Set(uriSchemes->MdcaPoint(0));

  6403 		if (ptrC.Compare(KExpectedText)==0)

  6404 			{

  6405 			verdict = EPass;

  6406 			}

  6407 		else

  6408 			{

  6409 			verdict = EFail;

  6410 			}

  6411     	}

  6413 	//--------------------//

  6415 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6416 	controller1.Close();

  6418 	if (error)

  6419 		{

  6420 		verdict = EFail;

  6421 		}

  6423 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6424 	__MM_HEAP_MARKEND;

  6426 	return verdict;

  6427 	}

  6431 //------------------------------------------------------------

  6435 //---------------------------------------------------------------

  6437 CTestStep_MMF_CTLFRM_U_0152::CTestStep_MMF_CTLFRM_U_0152()

  6438 	/** Constructor

  6439 	*/

  6440 	{

  6441 	// store the name of this test case

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

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

  6444 	iTestStepName = _L("MM-MMF-CTLFRM-U-0152");

  6445 	}

  6452 TVerdict CTestStep_MMF_CTLFRM_U_0152::DoTestStepL( void )

  6453 /**

  6454  * Call the RMMFController::Open(..) for a number of controllers and determine what Heap size has been allocated.

  6455  *

  6456  * This test needs access to the private member iSubThread in RMMFControllerProxy. To achieve this,

  6457  * private has been #defined to public oprior to including MmfControllerFramework.h and them #undef.

  6458  * This avoided the use of a friend declaration, but may later result in a maintenance problem.

  6459  *

  6460  * Test for fix to INC038123

  6461  */

  6462 	{

  6464 	INFO_PRINTF1(_L("The test step is not available on EKA2 - Skipping test!"));

  6465 	return EPass;

  6467 	}

  6470 //---------------------------------------------------------------

  6472 CTestStep_MMF_CTLFRM_U_0160::CTestStep_MMF_CTLFRM_U_0160()

  6473 	/** Constructor

  6474 	*/

  6475 	{

  6476 	// store the name of this test case

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

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

  6479 	iTestStepName = _L("MM-MMF-CTLFRM-U-0160");

  6482 	}

  6484 TVerdict CTestStep_MMF_CTLFRM_U_0160::DoTestStepL( void )

  6485 /**

  6486  * Use case: N/A

  6487  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6488  */

  6489 	{

  6490 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6491 	__MM_HEAP_MARK;

  6493 	TVerdict verdict = EPass;

  6494 	_LIT8(KExpectedText, ".ai");

  6497 	TMMFPrioritySettings settings;

  6498 	TInt error = KErrNone;

  6499 	RMMFController controller1;

  6501 	settings.iPriority = 1;

  6502 	settings.iPref = EMdaPriorityPreferenceTime;

  6503 	settings.iState = EMMFStateIdle;

  6505 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6506 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6508 	// Set the format match data

  6509 	fSelect->SetMatchToFileNameL(_L("test.ai"));

  6512 	// Set the controller plugin play format match data

  6513 	cSelect->SetRequiredRecordFormatSupportL(*fSelect);

  6515 	// Get Controllers

  6516 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6517 	CleanupResetAndDestroyPushL(controllers);

  6518 	cSelect->ListImplementationsL(controllers); // Populates the array with all the suitable controllers

  6519 	if (controllers.Count() > 0 )

  6520 		{

  6521 		RMMFFormatImplInfoArray controllersRecordFormats = controllers[0]->RecordFormats();

  6522 		INFO_PRINTF2(_L("Number of Record Formats: %d"),controllersRecordFormats.Count());

  6523 		for (TInt recordFormatCount = 0;recordFormatCount < controllersRecordFormats.Count();recordFormatCount++)

  6524 			{

  6525 			//---------------------//

  6526 			// Method being Tested //

  6527 			const CDesC8Array* fileExtensions = &controllersRecordFormats[recordFormatCount]->SupportedFileExtensions();

  6528 			//---------------------//

  6529 		 	if (fileExtensions->Count() > 0)

  6530             	{

  6531 				TPtrC8 ptrC;

  6532 				ptrC.Set(fileExtensions->MdcaPoint(0));

  6533 				if (ptrC.Compare(KExpectedText)==0)

  6534 					{

  6535 					verdict = EPass;

  6536 					break;

  6537 					}

  6538 				else

  6539 					{

  6540 					verdict = EFail;

  6541 					}

  6542             	}

  6543 			}

  6544 		}

  6545 	else

  6546 		{

  6547 		verdict = EFail;

  6548 		}

  6549 	if (controllers.Count() >0)//if loop added so that it will enter into loop only if Controller count >0

  6550 		{

  6551 		User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6552 		controller1.Close();

  6553 		}

  6554 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6555 	if (error)

  6556 		{

  6557 		verdict = EFail;

  6558 		}

  6559 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6560 	__MM_HEAP_MARKEND;

  6561 	return verdict;

  6562 	}

  6564 //---------------------------------------------------------------

  6568 CTestStep_MMF_CTLFRM_U_0161::CTestStep_MMF_CTLFRM_U_0161()

  6569 	/** Constructor

  6570 	*/

  6571 	{

  6572 	// store the name of this test case

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

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

  6575 	iTestStepName = _L("MM-MMF-CTLFRM-U-0161");

  6578 	}

  6580 TVerdict CTestStep_MMF_CTLFRM_U_0161::DoTestStepL( void )

  6581 /**

  6582  * Use case: N/A

  6583  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6584  */

  6585 	{

  6586 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6587 	__MM_HEAP_MARK;

  6589 	TVerdict verdict = EPass;

  6590 	_LIT8(KExpectedText,"audio/mbeg");

  6592 	TMMFPrioritySettings settings;

  6593 	TInt error = KErrNone;

  6594 	RMMFController controller1;

  6596 	settings.iPriority = 1;

  6597 	settings.iPref = EMdaPriorityPreferenceTime;

  6598 	settings.iState = EMMFStateIdle;

  6600 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6601 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6603 	// Set the format match data

  6604 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  6606 	// Set the controller plugin play format match data

  6607 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  6608 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  6610 	// Get Controllers

  6611 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6612 	CleanupResetAndDestroyPushL(controllers);

  6613 	cSelect->ListImplementationsL(controllers); // Populates the array with all the suitable controllers

  6615 	if (controllers.Count() > 0)

  6616 		{

  6617 		RMMFFormatImplInfoArray controllersPlayFormats = controllers[0]->PlayFormats();

  6618 		INFO_PRINTF2(_L("Number of Play Formats: %d"),controllersPlayFormats.Count());

  6620 		if (controllersPlayFormats.Count() > 0)

  6621 			{

  6622 			//---------------------//

  6623 			// Method being Tested //

  6624 			const CDesC8Array* mimeTypes = &controllersPlayFormats[1]->SupportedMimeTypes();

  6625 			//---------------------//

  6627 			if (mimeTypes->Count() <= 0)

  6628 				{

  6629 				verdict = EFail;

  6630 				}

  6631 			else

  6632 				{

  6633 				TPtrC8 ptrC;

  6634 				ptrC.Set(mimeTypes->MdcaPoint(0));

  6635 				if (ptrC.Compare(KExpectedText) == 0)

  6636 					{

  6637 					verdict = EPass;

  6638 					}

  6639 				else

  6640 					{

  6641 					verdict = EFail;

  6642 					}

  6643 				}

  6644 			}

  6645 		else

  6646 			{

  6647 			verdict = EFail;

  6648 			}

  6649 		}

  6650 	else

  6651 		{

  6652 		verdict = EFail;

  6653 		}

  6656 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6658 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6659 	controller1.Close();

  6661 	if (error)

  6662 		{

  6663 		verdict = EFail;

  6664 		}

  6666 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6667 	__MM_HEAP_MARKEND;

  6669 	return verdict;

  6670 	}

  6672 //---------------------------------------------------------------

  6675 CTestStep_MMF_CTLFRM_U_0162::CTestStep_MMF_CTLFRM_U_0162()

  6676 	/** Constructor

  6677 	*/

  6678 	{

  6679 	// store the name of this test case

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

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

  6682 	iTestStepName = _L("MM-MMF-CTLFRM-U-0162");

  6685 	}

  6687 TVerdict CTestStep_MMF_CTLFRM_U_0162::DoTestStepL( void )

  6688 /**

  6689  * Use case: N/A

  6690  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6691  */

  6692 	{

  6693 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6694 	__MM_HEAP_MARK;

  6696 	TVerdict verdict = EPass;

  6697 	_LIT8(KExpectedText, "RIFF????PAVE");

  6699 	TMMFPrioritySettings settings;

  6700 	TInt error = KErrNone;

  6701 	RMMFController controller1;

  6703 	settings.iPriority = 1;

  6704 	settings.iPref = EMdaPriorityPreferenceTime;

  6705 	settings.iState = EMMFStateIdle;

  6707 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6708 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6710 	// Set the format match data

  6711 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  6713 	// Set the controller plugin play format match data

  6714 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  6715 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  6717 	// Get Controllers

  6718 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6719 	CleanupResetAndDestroyPushL(controllers);

  6720 	cSelect->ListImplementationsL(controllers); // Populates the array with all the suitable controllers

  6722 	//---------------------//

  6723 	// Method being Tested //

  6724 	//---------------------//

  6725 	RMMFFormatImplInfoArray controllersPlayFormats = controllers[0]->PlayFormats();

  6726 	INFO_PRINTF2(_L("Number of Play Formats: %d"),controllersPlayFormats.Count());

  6728 	if (controllersPlayFormats.Count() > 0)

  6729 		{

  6730 		//---------------------//

  6731 		// Method being Tested //

  6732 		const CDesC8Array* headerData = &controllersPlayFormats[0]->SupportedHeaderData();

  6733 		//---------------------//

  6735 		if (headerData->Count() <= 0)

  6736 			{

  6737 			verdict = EFail;

  6738 			}

  6739 		else

  6740 			{

  6741 			TPtrC8 ptrC;

  6742 			ptrC.Set(headerData->MdcaPoint(0));

  6743 			if (ptrC.Compare(KExpectedText)==0)

  6744 				{

  6745 				verdict = EPass;

  6746 				}

  6747 			else

  6748 				{

  6749 				verdict = EFail;

  6750 				}

  6751 			}

  6752 		}

  6753 	else

  6754 		{

  6755 		verdict = EFail;

  6756 		}

  6758 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6760 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6761 	controller1.Close();

  6763 	if (error)

  6764 		{

  6765 		verdict = EFail;

  6766 		}

  6768 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6769 	__MM_HEAP_MARKEND;

  6771 	return verdict;

  6772 	}

  6774 //---------------------------------------------------------------

  6777 CTestStep_MMF_CTLFRM_U_0163::CTestStep_MMF_CTLFRM_U_0163()

  6778 	/** Constructor

  6779 	*/

  6780 	{

  6781 	// store the name of this test case

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

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

  6784 	iTestStepName = _L("MM-MMF-CTLFRM-U-0163");

  6787 	}

  6789 TVerdict CTestStep_MMF_CTLFRM_U_0163::DoTestStepL( void )

  6790 /**

  6791  * Use case: N/A

  6792  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6793  */

  6794 	{

  6795 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6796 	__MM_HEAP_MARK;

  6798 	TVerdict verdict = EPass;

  6799 	_LIT8(KExpectedText, ".ai");

  6801 	TMMFPrioritySettings settings;

  6802 	TInt error = KErrNone;

  6803 	RMMFController controller1;

  6805 	settings.iPriority = 1;

  6806 	settings.iPref = EMdaPriorityPreferenceTime;

  6807 	settings.iState = EMMFStateIdle;

  6809 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6810 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6812 	// Set the format match data

  6813 	fSelect->SetMatchToFileNameL(_L("test.ai"));

  6815 	// Set the controller plugin play format match data

  6816 	cSelect->SetRequiredRecordFormatSupportL(*fSelect);

  6817 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  6819 	// Get Controllers

  6820 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6821 	CleanupResetAndDestroyPushL(controllers);

  6822 	cSelect->ListImplementationsL(controllers); // Populates the array with all the suitable controllers

  6823 	if (controllers.Count() > 0)

  6824 		{

  6825 		//---------------------//

  6826 		// Method being Tested //

  6827 		//---------------------//

  6828 		RMMFFormatImplInfoArray controllersRecordFormats = controllers[0]->RecordFormats();

  6829 		INFO_PRINTF2(_L("Number of Record Formats: %d"),controllersRecordFormats.Count());

  6830 		TBufC8<32> bufC8Expected;

  6831 		bufC8Expected = KExpectedText;

  6832 		for (TInt recordFormatCount=0;recordFormatCount<controllersRecordFormats.Count();recordFormatCount++)

  6833 			{

  6834 			TBool fileExtensionSupported = controllersRecordFormats[recordFormatCount]->SupportsFileExtension(bufC8Expected);

  6835 			if (fileExtensionSupported)

  6836 				{

  6837 				verdict = EPass;

  6838 				break;

  6839 				}

  6840 			else if (!fileExtensionSupported)

  6841 				{

  6842 				verdict = EFail;

  6843 				}

  6844 			}

  6845 		}

  6846 	else

  6847 		{

  6848 		verdict = EFail;

  6849 		}

  6851 	if (controllers.Count() >0) //if loop added so that it will enter into loop only if Controller count >0

  6852 		{

  6853 		User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6854 		controller1.Close();

  6855 		}

  6856 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6857 	if (error)

  6858 		{

  6859 		verdict = EFail;

  6860 		}

  6862 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6863 	__MM_HEAP_MARKEND;

  6865 	return verdict;

  6866 	}

  6868 //---------------------------------------------------------------

  6872 CTestStep_MMF_CTLFRM_U_0164::CTestStep_MMF_CTLFRM_U_0164()

  6873 	/** Constructor

  6874 	*/

  6875 	{

  6876 	// store the name of this test case

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

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

  6879 	iTestStepName = _L("MM-MMF-CTLFRM-U-0164");

  6882 	}

  6884 TVerdict CTestStep_MMF_CTLFRM_U_0164::DoTestStepL( void )

  6885 /**

  6886  * Use case: N/A

  6887  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6888  */

  6889 	{

  6890 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6891 	__MM_HEAP_MARK;

  6893 	TVerdict verdict = EPass;

  6894 	_LIT8(KExpectedText, "audio/mbeg");

  6896 	TMMFPrioritySettings settings;

  6897 	TInt error = KErrNone;

  6898 	RMMFController controller1;

  6900 	settings.iPriority = 1;

  6901 	settings.iPref = EMdaPriorityPreferenceTime;

  6902 	settings.iState = EMMFStateIdle;

  6904 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6905 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6907 	// Set the format match data

  6908 	fSelect->SetMatchToFileNameL(_L("test.mp3"));

  6910 	// Set the controller plugin play format match data

  6911 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  6912 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  6914 	// Get Controllers

  6915 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  6916 	CleanupResetAndDestroyPushL(controllers);

  6917 	cSelect->ListImplementationsL(controllers); // Populates the array with all the suitable controllers

  6919 	//---------------------//

  6920 	// Method being Tested //

  6921 	//---------------------//

  6922 	RMMFFormatImplInfoArray controllersPlayFormats = controllers[0]->PlayFormats();

  6923 	INFO_PRINTF2(_L("Number of Play Formats: %d"),controllersPlayFormats.Count());

  6925 	if (controllersPlayFormats.Count() > 0)

  6926 		{

  6927 		TBufC8<32> bufC8Expected;

  6928 		bufC8Expected = KExpectedText;

  6929 		//---------------------//

  6930 		// Method being Tested //

  6931 		TBool mimeTypeSupported = controllersPlayFormats[1]->SupportsMimeType(bufC8Expected);

  6932 		//---------------------//

  6934 		if (!mimeTypeSupported)

  6935 			{

  6936 			verdict = EFail;

  6937 			}

  6938 		}

  6939 	else

  6940 		{

  6941 		verdict = EFail;

  6942 		}

  6944 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  6946 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  6947 	controller1.Close();

  6949 	if (error)

  6950 		{

  6951 		verdict = EFail;

  6952 		}

  6954 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  6955 	__MM_HEAP_MARKEND;

  6957 	return verdict;

  6958 	}

  6960 //---------------------------------------------------------------

  6963 CTestStep_MMF_CTLFRM_U_0165::CTestStep_MMF_CTLFRM_U_0165()

  6964 	/** Constructor

  6965 	*/

  6966 	{

  6967 	// store the name of this test case

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

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

  6970 	iTestStepName = _L("MM-MMF-CTLFRM-U-0165");

  6973 	}

  6975 TVerdict CTestStep_MMF_CTLFRM_U_0165::DoTestStepL( void )

  6976 /**

  6977  * Use case: N/A

  6978  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  6979  */

  6980 	{

  6981 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  6982 	__MM_HEAP_MARK;

  6984 	TVerdict verdict = EPass;

  6985 	_LIT8(KExpectedText, "RIFF????PAVE");

  6987 	TMMFPrioritySettings settings;

  6988 	TInt error = KErrNone;

  6989 	RMMFController controller1;

  6991 	settings.iPriority = 1;

  6992 	settings.iPref = EMdaPriorityPreferenceTime;

  6993 	settings.iState = EMMFStateIdle;

  6995 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  6996 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  6998 	// Set the format match data

  6999 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7001 	// Set the controller plugin play format match data

  7002 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7003 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7005 	// Get Controllers

  7006 	RMMFControllerImplInfoArray controllers; // Array to hold all the controllers support the match data

  7007 	CleanupResetAndDestroyPushL(controllers);

  7008 	cSelect->ListImplementationsL(controllers); // Populates the array with all the suitable controllers

  7010 	//---------------------//

  7011 	// Method being Tested //

  7012 	//---------------------//

  7013 	RMMFFormatImplInfoArray controllersPlayFormats = controllers[0]->PlayFormats();

  7014 	INFO_PRINTF2(_L("Number of Play Formats: %d"),controllersPlayFormats.Count());

  7016 	if (controllersPlayFormats.Count() > 0)

  7017 		{

  7018 		TBufC8<32> bufC8Expected;

  7019 		bufC8Expected = KExpectedText;

  7020 		//---------------------//

  7021 		// Method being Tested //

  7022 		TBool headerDataSupported = controllersPlayFormats[0]->SupportsHeaderDataL(bufC8Expected);

  7023 		//---------------------//

  7025 		if (!headerDataSupported)

  7026 			{

  7027 			verdict = EFail;

  7028 			}

  7029 		}

  7030 	else

  7031 		{

  7032 		verdict = EFail;

  7033 		}

  7035 	User::LeaveIfError(error = controller1.Open(controllers[0]->Uid(), settings)); // iinstantiate the controller

  7037 	CleanupStack::PopAndDestroy(3);//controllers, fSelect, cSelect

  7038 	controller1.Close();

  7040 	if (error)

  7041 		{

  7042 		verdict = EFail;

  7043 		}

  7045 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7046 	__MM_HEAP_MARKEND;

  7048 	return verdict;

  7049 	}

  7051 //---------------------------------------------------------------

  7055 CTestStep_MMF_CTLFRM_U_0170::CTestStep_MMF_CTLFRM_U_0170()

  7056 	/** Constructor

  7057 	*/

  7058 	{

  7059 	// store the name of this test case

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

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

  7062 	iTestStepName = _L("MM-MMF-CTLFRM-U-0170");

  7065 	}

  7067 TVerdict CTestStep_MMF_CTLFRM_U_0170::DoTestStepL( void )

  7068 /**

  7069  * Use case: N/A

  7070  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  7071  */

  7072 	{

  7073 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7074 	__MM_HEAP_MARK;

  7076 	TVerdict verdict = EPass;

  7077 //	TMMFPrioritySettings settings;					//EABI warning removal

  7079 //	settings.iPriority = 1;

  7080 //	settings.iPref = EMdaPriorityPreferenceTime;

  7081 //	settings.iState = EMMFStateIdle;

  7083 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7084 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7086 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7088 	// Set the format match data

  7089 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7091 	// Set the controller plugin play format match data

  7092 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7093 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7096 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7098 	//---------------------//

  7099 	// Method being Tested //

  7100 	//---------------------//

  7101 	fEncodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7102 	//---------------------//

  7104 	// Get Encode Format(s)

  7105 	RMMFFormatImplInfoArray formats;

  7106 	CleanupResetAndDestroyPushL(formats);

  7107 	fEncodeSelect->ListImplementationsL(formats);

  7110 	// Check the Uid is correct, hense the correct interface has been obtained

  7111 	TUid formatUid;

  7112 	formatUid = formats[0]->Uid();

  7113 	if (formatUid == KMmfUidFormatPAVWriteUid)

  7114 		{

  7115 		verdict = EPass;

  7116 		}

  7117 	else

  7118 		{

  7119 		verdict = EFail;

  7120 		}

  7122 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  7124 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7125 	__MM_HEAP_MARKEND;

  7127 	return verdict;

  7128 	}

  7130 //---------------------------------------------------------------

  7132 CTestStep_MMF_CTLFRM_U_0171::CTestStep_MMF_CTLFRM_U_0171()

  7133 	/** Constructor

  7134 	*/

  7135 	{

  7136 	// store the name of this test case

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

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

  7139 	iTestStepName = _L("MM-MMF-CTLFRM-U-0171");

  7142 	}

  7144 TVerdict CTestStep_MMF_CTLFRM_U_0171::DoTestStepL( void )

  7145 /**

  7146  * Use case: N/A

  7147  * @test Req.

  7148  */

  7149 	{

  7150 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7151 	__MM_HEAP_MARK;

  7153 	TVerdict verdict = EPass;

  7154 //	TMMFPrioritySettings settings;	//EABI warning removal

  7156 //	settings.iPriority = 1;

  7157 //	settings.iPref = EMdaPriorityPreferenceTime;

  7158 //	settings.iState = EMMFStateIdle;

  7160 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7161 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7163 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7165 	// Set the format match data

  7166 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7168 	// Set the controller plugin play format match data

  7169 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7170 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7172 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7174 	fEncodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7176 	//---------------------//

  7178 	// Get Encode Format(s)

  7179 	RMMFFormatImplInfoArray formats;

  7180 	CleanupResetAndDestroyPushL(formats);

  7181 	fEncodeSelect->ListImplementationsL(formats);

  7184 	RArray<TUid> mediaIds;

  7186 	//---------------------//

  7187 	// Method being Tested //

  7188 	//---------------------//

  7189 	fEncodeSelect->SetMediaIdsL(mediaIds, CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);

  7190 	//---------------------//

  7192 	TUid uid = {0x101FF9FF};

  7194 	if (mediaIds.Count() > 0)

  7195 		{

  7196 		if (mediaIds[0] == uid)

  7197 			{

  7198 			verdict = EPass;

  7199 			}

  7200 		}

  7201 	else

  7202 		{

  7203 		verdict = EFail;

  7204 		}

  7206 	// Check the Uid is correct, hense the correct interface has been obtained

  7207 	TUid formatUid;

  7208 	formatUid = formats[0]->Uid();

  7209 	if (formatUid == KMmfUidFormatPAVWriteUid)

  7210 		{

  7211 		verdict = EPass;

  7212 		}

  7213 	else

  7214 		{

  7215 		verdict = EFail;

  7216 		}

  7218 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  7220 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7221 	__MM_HEAP_MARKEND;

  7223 	return verdict;

  7224 	}

  7226 //---------------------------------------------------------------

  7229 CTestStep_MMF_CTLFRM_U_0172::CTestStep_MMF_CTLFRM_U_0172()

  7230 	/** Constructor

  7231 	*/

  7232 	{

  7233 	// store the name of this test case

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

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

  7236 	iTestStepName = _L("MM-MMF-CTLFRM-U-0172");

  7239 	}

  7241 TVerdict CTestStep_MMF_CTLFRM_U_0172::DoTestStepL( void )

  7242 /**

  7243  * Use case: N/A

  7244  * @test Req. under test

  7245  */

  7246 	{

  7247 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7248 	__MM_HEAP_MARK;

  7250 	TVerdict verdict = EPass;

  7251 	_LIT(KExpectedText, "Symbian");

  7253 //	TMMFPrioritySettings settings;	//EABI warning removal

  7255 //	settings.iPriority = 1;

  7256 //	settings.iPref = EMdaPriorityPreferenceTime;

  7257 //	settings.iState = EMMFStateIdle;

  7259 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7260 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7262 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7264 	// Set the format match data

  7265 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7267 	// Set the controller plugin play format match data

  7268 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7269 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7271 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7273 	fEncodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7274 	//---------------------//

  7276 	// Get Encode Format(s)

  7277 	RMMFFormatImplInfoArray formats;

  7278 	CleanupResetAndDestroyPushL(formats);

  7279 	fEncodeSelect->ListImplementationsL(formats);

  7281 	//---------------------//

  7282 	// Method being Tested //

  7283 	//---------------------//

  7284 	TBufC<12> bufC = fEncodeSelect->PreferredSupplier();

  7285 	//---------------------//

  7287 	if ((bufC == KExpectedText) && (verdict == EPass))

  7288 		{

  7289 		verdict = EPass;

  7290 		}

  7291 	else

  7292 		{

  7293 		verdict = EFail;

  7294 		}

  7296 	// Check the Uid is correct, hense the correct interface has been obtained

  7297 	TUid formatUid;

  7298 	formatUid = formats[0]->Uid();

  7299 	if (formatUid == KMmfUidFormatPAVWriteUid && verdict == EPass)

  7300 		{

  7301 		verdict = EPass;

  7302 		}

  7303 	else

  7304 		{

  7305 		verdict = EFail;

  7306 		}

  7308 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  7310 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7311 	__MM_HEAP_MARKEND;

  7313 	return verdict;

  7314 	}

  7316 //---------------------------------------------------------------

  7319 CTestStep_MMF_CTLFRM_U_0173::CTestStep_MMF_CTLFRM_U_0173()

  7320 	/** Constructor

  7321 	*/

  7322 	{

  7323 	// store the name of this test case

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

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

  7326 	iTestStepName = _L("MM-MMF-CTLFRM-U-0173");

  7329 	}

  7331 TVerdict CTestStep_MMF_CTLFRM_U_0173::DoTestStepL( void )

  7332 /**

  7333  * Use case: N/A

  7334  * @test Req. under test

  7335  */

  7336 	{

  7337 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7338 	__MM_HEAP_MARK;

  7340 	TVerdict verdict = EPass;

  7341 //	TMMFPrioritySettings settings;	//EABI warning removal

  7343 //	settings.iPriority = 1;

  7344 //	settings.iPref = EMdaPriorityPreferenceTime;

  7345 //	settings.iState = EMMFStateIdle;

  7347 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7348 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7350 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7352 	// Set the format match data

  7353 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7355 	// Set the controller plugin play format match data

  7356 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7357 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7359 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7361 	fEncodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7362 	//---------------------//

  7364 	// Get Encode Format(s)

  7365 	RMMFFormatImplInfoArray formats;

  7366 	CleanupResetAndDestroyPushL(formats);

  7367 	fEncodeSelect->ListImplementationsL(formats);

  7369 	//---------------------//

  7370 	// Method being Tested //

  7371 	//---------------------//

  7372 	if ((fEncodeSelect->PreferredSupplierMatchType() == CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned) && (verdict == EPass))

  7373 		{

  7374 		verdict = EPass;

  7375 		}

  7376 	else

  7377 		{

  7378 		verdict = EFail;

  7379 		}

  7380 	//---------------------//

  7382 	// Check the Uid is correct, hense the correct interface has been obtained

  7383 	TUid formatUid;

  7384 	formatUid = formats[0]->Uid();

  7385 	if (formatUid == KMmfUidFormatPAVWriteUid && verdict == EPass)

  7386 		{

  7387 		verdict = EPass;

  7388 		}

  7389 	else

  7390 		{

  7391 		verdict = EFail;

  7392 		}

  7394 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  7396 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7397 	__MM_HEAP_MARKEND;

  7399 	return verdict;

  7400 	}

  7402 //---------------------------------------------------------------

  7405 CTestStep_MMF_CTLFRM_U_0174::CTestStep_MMF_CTLFRM_U_0174()

  7406 	/** Constructor

  7407 	*/

  7408 	{

  7409 	// store the name of this test case

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

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

  7412 	iTestStepName = _L("MM-MMF-CTLFRM-U-0174");

  7415 	}

  7417 TVerdict CTestStep_MMF_CTLFRM_U_0174::DoTestStepL( void )

  7418 /**

  7419  * Use case: N/A

  7420  * @test Req. under test

  7421  */

  7422 	{

  7423 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7424 	__MM_HEAP_MARK;

  7426 	TVerdict verdict = EPass;

  7427 //	TMMFPrioritySettings settings;	//EABI warning removal

  7429 //	settings.iPriority = 1;

  7430 //	settings.iPref = EMdaPriorityPreferenceTime;

  7431 //	settings.iState = EMMFStateIdle;

  7433 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7434 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7436 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7438 	// Set the format match data

  7439 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7441 	// Set the controller plugin play format match data

  7442 	cSelect->SetRequiredRecordFormatSupportL(*fSelect);

  7443 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7445 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7447 	fEncodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7448 	//---------------------//

  7450 	// Get Encode Format(s)

  7451 	RMMFFormatImplInfoArray formats;

  7452 	CleanupResetAndDestroyPushL(formats);

  7453 	fEncodeSelect->ListImplementationsL(formats);

  7455 	TUid testUid = {0x12345679};

  7456 	RArray<TUid> mediaIdsToAdd;

  7457 	mediaIdsToAdd.Append(testUid);

  7459 	fEncodeSelect->SetMediaIdsL(mediaIdsToAdd, CMMFPluginSelectionParameters::EAllowOtherMediaIds);

  7461 	//---------------------//

  7462 	// Method being Tested //

  7463 	//---------------------//

  7464 	const RArray<TUid>& mediaIds = fEncodeSelect->MediaIds();

  7465 	//---------------------//

  7467 	if (mediaIds.Count() > 0)

  7468 		{

  7469 		TUid uid = {0x12345679};

  7471 		if (mediaIds[0] == uid)

  7472 			{

  7473 			verdict = EPass;

  7474 			}

  7475 		else

  7476 			{

  7477 			verdict = EFail;

  7478 			}

  7479 		}

  7480 	else

  7481 		{

  7482 		verdict = EFail;

  7483 		}

  7485 	// Check the Uid is correct, hense the correct interface has been obtained

  7486 	TUid formatUid;

  7487 	formatUid = formats[0]->Uid();

  7488 	if (formatUid == KMmfUidFormatPAVWriteUid && verdict == EPass)

  7489 		{

  7490 		verdict = EPass;

  7491 		}

  7492 	else

  7493 		{

  7494 		verdict = EFail;

  7495 		}

  7498 	mediaIdsToAdd.Remove(0); // Remove otherwise TUid will be destroyed below and Panic.

  7499 	mediaIdsToAdd.Close();

  7501 	CleanupStack::PopAndDestroy(4);// formats, fSelect, cSelect, fEncodeSelect

  7503 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7504 	__MM_HEAP_MARKEND;

  7506 	return verdict;

  7507 	}

  7509 //---------------------------------------------------------------

  7511 CTestStep_MMF_CTLFRM_U_0175::CTestStep_MMF_CTLFRM_U_0175()

  7512 	/** Constructor

  7513 	*/

  7514 	{

  7515 	// store the name of this test case

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

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

  7518 	iTestStepName = _L("MM-MMF-CTLFRM-U-0175");

  7521 	}

  7523 TVerdict CTestStep_MMF_CTLFRM_U_0175::DoTestStepL( void )

  7524 /**

  7525  * Use case: N/A

  7526  * @test Req. under test

  7527  */

  7528 	{

  7529 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7530 	__MM_HEAP_MARK;

  7532 	TVerdict verdict = EPass;

  7533 //	TMMFPrioritySettings settings;	//EABI warning removal

  7535 //	settings.iPriority = 1;

  7536 //	settings.iPref = EMdaPriorityPreferenceTime;

  7537 //	settings.iState = EMMFStateIdle;

  7539 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7540 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7542 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7544 	// Set the format match data

  7545 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7547 	// Set the controller plugin play format match data

  7548 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7549 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7551 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7553 	fEncodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7554 	//---------------------//

  7556 	// Get Encode Format(s)

  7557 	RMMFFormatImplInfoArray formats;

  7558 	CleanupResetAndDestroyPushL(formats);

  7559 	fEncodeSelect->ListImplementationsL(formats);

  7561 	//---------------------//

  7562 	// Method being Tested //

  7563 	//---------------------//

  7564 	if ((fEncodeSelect->MediaIdMatchType() == CMMFPluginSelectionParameters::ENoMediaIdMatch) && (verdict == EPass))

  7565 		{

  7566 		verdict = EPass;

  7567 		}

  7568 	else

  7569 		{

  7570 		verdict = EFail;

  7571 		}

  7572 	//---------------------//

  7574 	// Check the Uid is correct, hense the correct interface has been obtained

  7575 	TUid formatUid;

  7576 	formatUid = formats[0]->Uid();

  7577 	if (formatUid == KMmfUidFormatPAVWriteUid && verdict == EPass)

  7578 		{

  7579 		verdict = EPass;

  7580 		}

  7581 	else

  7582 		{

  7583 		verdict = EFail;

  7584 		}

  7586 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  7588 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7589 	__MM_HEAP_MARKEND;

  7591 	return verdict;

  7592 	}

  7594 //---------------------------------------------------------------

  7596 CTestStep_MMF_CTLFRM_U_0176::CTestStep_MMF_CTLFRM_U_0176()

  7597 	/** Constructor

  7598 	*/

  7599 	{

  7600 	// store the name of this test case

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

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

  7603 	iTestStepName = _L("MM-MMF-CTLFRM-U-0176");

  7606 	}

  7608 TVerdict CTestStep_MMF_CTLFRM_U_0176::DoTestStepL( void )

  7609 /**

  7610  * Use case: N/A

  7611  * @test Req. under test

  7612  */

  7613 	{

  7614 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7615 	__MM_HEAP_MARK;

  7617 	TVerdict verdict = EPass;

  7618 //	TMMFPrioritySettings settings;		//EABI warning removal

  7620 //	settings.iPriority = 1;

  7621 //	settings.iPref = EMdaPriorityPreferenceTime;

  7622 //	settings.iState = EMMFStateIdle;

  7624 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7625 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7627 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7629 	// Set the format match data

  7630 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7632 	// Set the controller plugin play format match data

  7633 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7634 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7636 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7638 	fEncodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7639 	//---------------------//

  7641 	// Get Encode Format(s)

  7642 	RMMFFormatImplInfoArray formats;

  7643 	CleanupResetAndDestroyPushL(formats);

  7644 	fEncodeSelect->ListImplementationsL(formats);

  7646 	//---------------------//

  7647 	// Method being Tested //

  7648 	//---------------------//

  7649 	TUid uid = fEncodeSelect->InterfaceUid();

  7650 	//---------------------//

  7652 	if (uid == KMmfUidPluginInterfaceFormatEncodeUid)

  7653 		{

  7654 		verdict = EPass;

  7655 		}

  7656 	else

  7657 		{

  7658 		verdict = EFail;

  7659 		}

  7663 	// Check the Uid is correct, hense the correct interface has been obtained

  7664 	TUid formatUid;

  7665 	formatUid = formats[0]->Uid();

  7666 	if (formatUid == KMmfUidFormatPAVWriteUid && verdict == EPass)

  7667 		{

  7668 		verdict = EPass;

  7669 		}

  7670 	else

  7671 		{

  7672 		verdict = EFail;

  7673 		}

  7675 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  7677 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7678 	__MM_HEAP_MARKEND;

  7680 	return verdict;

  7681 	}

  7683 //---------------------------------------------------------------

  7687 CTestStep_MMF_CTLFRM_U_0180::CTestStep_MMF_CTLFRM_U_0180()

  7688 	/** Constructor

  7689 	*/

  7690 	{

  7691 	// store the name of this test case

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

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

  7694 	iTestStepName = _L("MM-MMF-CTLFRM-U-0180");

  7697 	}

  7699 TVerdict CTestStep_MMF_CTLFRM_U_0180::DoTestStepL( void )

  7700 /**

  7701  * Use case: N/A

  7702  * @test Req. under test

  7703  */

  7704 	{

  7705 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7706 	__MM_HEAP_MARK;

  7708 	TVerdict verdict = EPass;

  7709 //	TMMFPrioritySettings settings;	//EABI warning removal

  7711 //	settings.iPriority = 1;

  7712 //	settings.iPref = EMdaPriorityPreferenceTime;

  7713 //	settings.iState = EMMFStateIdle;

  7715 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7716 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7718 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7720 	// Set the format match data

  7721 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7723 	// Set the controller plugin play format match data

  7724 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7725 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7728 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7730 	//---------------------//

  7731 	// Method being Tested //

  7732 	//---------------------//

  7733 	fEncodeSelect->SetPreferredSupplierL(_L("Simbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7734 	//---------------------//

  7736 	// Get Encode Format(s)

  7737 	RMMFFormatImplInfoArray formats;

  7738 	CleanupResetAndDestroyPushL(formats);

  7739 	fEncodeSelect->ListImplementationsL(formats);

  7742 	// Check the Uid is correct, hense the correct interface has been obtained

  7743 	TUid formatUid;

  7745 	if (formats.Count() > 0)

  7746 		{

  7747 		formatUid = formats[0]->Uid();

  7748 		if (formatUid == KMmfUidFormatPAVWriteUid)

  7749 			{

  7750 			verdict = EFail;  // Wrong if correct ID occurs

  7751 			}

  7752 		else

  7753 			{

  7754 			verdict = EPass;

  7755 			}

  7756 		}

  7757 	else

  7758 		{

  7759 		verdict = EPass;

  7760 		}

  7762 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  7764 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7765 	__MM_HEAP_MARKEND;

  7767 	return verdict;

  7768 	}

  7770 //---------------------------------------------------------------

  7772 CTestStep_MMF_CTLFRM_U_0181::CTestStep_MMF_CTLFRM_U_0181()

  7773 	/** Constructor

  7774 	*/

  7775 	{

  7776 	// store the name of this test case

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

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

  7779 	iTestStepName = _L("MM-MMF-CTLFRM-U-0181");

  7782 	}

  7784 TVerdict CTestStep_MMF_CTLFRM_U_0181::DoTestStepL( void )

  7785 /**

  7786  * Use case: N/A

  7787  * @test Req. under test

  7788  */

  7789 	{

  7790 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7791 	__MM_HEAP_MARK;

  7793 	TVerdict verdict = EPass;

  7795 //	TMMFPrioritySettings settings;	//EABI warning removal

  7797 //	settings.iPriority = 1;

  7798 //	settings.iPref = EMdaPriorityPreferenceTime;

  7799 //	settings.iState = EMMFStateIdle;

  7801 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7802 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7804 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7806 	// Set the format match data

  7807 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7809 	// Set the controller plugin play format match data

  7810 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7811 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7813 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7815 	fEncodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7817 	//---------------------//

  7819 	// Get Encode Format(s)

  7820 	RMMFFormatImplInfoArray formats;

  7821 	CleanupResetAndDestroyPushL(formats);

  7822 	fEncodeSelect->ListImplementationsL(formats);

  7825 	RArray<TUid> mediaIds;

  7827 	//---------------------//

  7828 	// Method being Tested //

  7829 	//---------------------//

  7830 	// Incorrect Enum Passed

  7831 	fEncodeSelect->SetMediaIdsL(mediaIds, CMMFPluginSelectionParameters::EAllowOtherMediaIds);

  7832 	//---------------------//

  7834 	TUid uid = {0x101FF9FF};

  7836 	// Should return nothing

  7837 	if (mediaIds.Count() > 0)

  7838 		{

  7839 		if (mediaIds[0] == uid)

  7840 			{

  7841 			verdict = EFail;

  7842 			}

  7843 		}

  7844 	else

  7845 		{

  7846 		verdict = EPass;

  7847 		}

  7849 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  7851 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7852 	__MM_HEAP_MARKEND;

  7854 	return verdict;

  7855 	}

  7857 //---------------------------------------------------------------

  7860 CTestStep_MMF_CTLFRM_U_0182::CTestStep_MMF_CTLFRM_U_0182()

  7861 	/** Constructor

  7862 	*/

  7863 	{

  7864 	// store the name of this test case

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

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

  7867 	iTestStepName = _L("MM-MMF-CTLFRM-U-0182");

  7870 	}

  7872 TVerdict CTestStep_MMF_CTLFRM_U_0182::DoTestStepL( void )

  7873 /**

  7874  * Use case: N/A

  7875  * @test Req. under test

  7876  */

  7877 	{

  7878 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7879 	__MM_HEAP_MARK;

  7881 	TVerdict verdict = EPass;

  7882 	_LIT(KExpectedText, "Symbian");

  7884 //	TMMFPrioritySettings settings;	//EABI warning removal

  7886 //	settings.iPriority = 1;

  7887 //	settings.iPref = EMdaPriorityPreferenceTime;

  7888 //	settings.iState = EMMFStateIdle;

  7890 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7891 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7893 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7895 	// Set the format match data

  7896 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7898 	// Set the controller plugin play format match data

  7899 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7900 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7902 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7904 	fEncodeSelect->SetPreferredSupplierL(_L("Simbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7905 	//---------------------//

  7907 	// Get Encode Format(s)

  7908 	RMMFFormatImplInfoArray formats;

  7909 	CleanupResetAndDestroyPushL(formats);

  7910 	fEncodeSelect->ListImplementationsL(formats);

  7912 	//---------------------//

  7913 	// Method being Tested //

  7914 	//---------------------//

  7915 	TBufC<12> bufC = fEncodeSelect->PreferredSupplier();

  7916 	//---------------------//

  7918 	// Shouldn't return Symbian, should be Simbian

  7919 	if ((bufC == KExpectedText) && (verdict == EPass))

  7920 		{

  7921 		verdict = EFail;

  7922 		}

  7923 	else

  7924 		{

  7925 		verdict = EPass;

  7926 		}

  7928 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  7930 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  7931 	__MM_HEAP_MARKEND;

  7933 	return verdict;

  7934 	}

  7936 //---------------------------------------------------------------

  7939 CTestStep_MMF_CTLFRM_U_0183::CTestStep_MMF_CTLFRM_U_0183()

  7940 	/** Constructor

  7941 	*/

  7942 	{

  7943 	// store the name of this test case

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

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

  7946 	iTestStepName = _L("MM-MMF-CTLFRM-U-0183");

  7949 	}

  7951 TVerdict CTestStep_MMF_CTLFRM_U_0183::DoTestStepL( void )

  7952 /**

  7953  * Use case: N/A

  7954  * @test Req. under test

  7955  */

  7956 	{

  7957 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  7958 	__MM_HEAP_MARK;

  7960 	TVerdict verdict = EPass;

  7961 //	TMMFPrioritySettings settings;	//EABI warning removal

  7963 //	settings.iPriority = 1;

  7964 //	settings.iPref = EMdaPriorityPreferenceTime;

  7965 //	settings.iState = EMMFStateIdle;

  7967 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  7968 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  7970 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  7972 	// Set the format match data

  7973 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  7975 	// Set the controller plugin play format match data

  7976 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  7977 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  7979 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  7981 	fEncodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  7982 	//---------------------//

  7984 	// Get Encode Format(s)

  7985 	RMMFFormatImplInfoArray formats;

  7986 	CleanupResetAndDestroyPushL(formats);

  7987 	fEncodeSelect->ListImplementationsL(formats);

  7989 	//---------------------//

  7990 	// Method being Tested //

  7991 	//---------------------//

  7992 	if ((fEncodeSelect->PreferredSupplierMatchType() == CMMFPluginSelectionParameters::ENoPreferredSupplierMatch) && (verdict == EFail))

  7993 		{

  7994 		verdict = EFail;

  7995 		}

  7996 	else

  7997 		{

  7998 		verdict = EPass;

  7999 		}

  8000 	//---------------------//

  8002 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  8004 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  8005 	__MM_HEAP_MARKEND;

  8007 	return verdict;

  8008 	}

  8010 //---------------------------------------------------------------

  8013 CTestStep_MMF_CTLFRM_U_0184::CTestStep_MMF_CTLFRM_U_0184()

  8014 	/** Constructor

  8015 	*/

  8016 	{

  8017 	// store the name of this test case

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

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

  8020 	iTestStepName = _L("MM-MMF-CTLFRM-U-0184");

  8023 	}

  8025 TVerdict CTestStep_MMF_CTLFRM_U_0184::DoTestStepL( void )

  8026 /**

  8027  * Use case: N/A

  8028  * @test Req. under test

  8029  */

  8030 	{

  8031 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8032 	__MM_HEAP_MARK;

  8034 	TVerdict verdict = EPass;

  8035 //	TMMFPrioritySettings settings;	//EABI warning removal

  8037 //	settings.iPriority = 1;

  8038 //	settings.iPref = EMdaPriorityPreferenceTime;

  8039 //	settings.iState = EMMFStateIdle;

  8041 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  8042 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8044 	CMMFFormatEncodePluginSelectionParameters* fEncodeSelect = CMMFFormatEncodePluginSelectionParameters::NewLC();

  8046 	// Set the format match data

  8047 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  8049 	// Set the controller plugin play format match data

  8050 	cSelect->SetRequiredRecordFormatSupportL(*fSelect);

  8051 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  8053 	fEncodeSelect->SetRequiredFormatSupportL(*fSelect);

  8055 	fEncodeSelect->SetPreferredSupplierL(_L("Simbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  8056 	//---------------------//

  8058 	// Get Encode Format(s)

  8059 	RMMFFormatImplInfoArray formats;

  8060 	CleanupResetAndDestroyPushL(formats);

  8061 	fEncodeSelect->ListImplementationsL(formats);

  8063 	RArray<TUid> mediaIdsToAdd;

  8065 	// Pass Empty Array

  8066 	fEncodeSelect->SetMediaIdsL(mediaIdsToAdd, CMMFPluginSelectionParameters::EAllowOtherMediaIds);

  8069 	//---------------------//

  8070 	// Method being Tested //

  8071 	//---------------------//

  8072 	const RArray<TUid>& mediaIds = fEncodeSelect->MediaIds();

  8073 	//---------------------//

  8075 	if (mediaIds.Count() > 0)

  8076 		{

  8077 		TUid uid = {0x12345679};

  8078 		if (mediaIds[0] == uid)

  8079 			{

  8080 			verdict = EFail;

  8081 			}

  8082 		else

  8083 			{

  8084 			verdict = EPass;

  8085 			}

  8086 		}

  8087 	else

  8088 		{

  8089 		verdict = EPass;

  8090 		}

  8092 	mediaIdsToAdd.Close();

  8094 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fEncodeSelect

  8096 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  8097 	__MM_HEAP_MARKEND;

  8099 	return verdict;

  8100 	}

  8102 //---------------------------------------------------------------

  8105 CTestStep_MMF_CTLFRM_U_0190::CTestStep_MMF_CTLFRM_U_0190()

  8106 	/** Constructor

  8107 	*/

  8108 	{

  8109 	// store the name of this test case

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

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

  8112 	iTestStepName = _L("MM-MMF-CTLFRM-U-0190");

  8115 	}

  8117 TVerdict CTestStep_MMF_CTLFRM_U_0190::DoTestStepL( void )

  8118 /**

  8119  * Use case: N/A

  8120  * @test Req. under test

  8121  */

  8122 	{

  8123 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8124 	__MM_HEAP_MARK;

  8126 	TVerdict verdict = EPass;

  8127 //	TMMFPrioritySettings settings;	//EABI warning removal

  8129 //	settings.iPriority = 1;

  8130 //	settings.iPref = EMdaPriorityPreferenceTime;

  8131 //	settings.iState = EMMFStateIdle;

  8133 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  8134 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8136 	CMMFFormatDecodePluginSelectionParameters* fDecodeSelect = CMMFFormatDecodePluginSelectionParameters::NewLC();

  8138 	// Set the format match data

  8139 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  8141 	// Set the controller plugin play format match data

  8142 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  8143 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  8146 	fDecodeSelect->SetRequiredFormatSupportL(*fSelect);

  8148 	//---------------------//

  8149 	// Method being Tested //

  8150 	//---------------------//

  8151 	fDecodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  8152 	//---------------------//

  8154 	// Get Decode Format(s)

  8155 	RMMFFormatImplInfoArray formats;

  8156 	CleanupResetAndDestroyPushL(formats);

  8157 	fDecodeSelect->ListImplementationsL(formats);

  8160 	// Check the Uid is correct, hense the correct interface has been obtained

  8161 	TUid formatUid;

  8162 	formatUid = formats[0]->Uid();

  8163 	if (formatUid == KMmfUidFormatPAVReadUid)

  8164 		{

  8165 		verdict = EPass;

  8166 		}

  8167 	else

  8168 		{

  8169 		verdict = EFail;

  8170 		}

  8172 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fDecodeSelect

  8174 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  8175 	__MM_HEAP_MARKEND;

  8177 	return verdict;

  8178 	}

  8180 //---------------------------------------------------------------

  8182 CTestStep_MMF_CTLFRM_U_0191::CTestStep_MMF_CTLFRM_U_0191()

  8183 	/** Constructor

  8184 	*/

  8185 	{

  8186 	// store the name of this test case

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

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

  8189 	iTestStepName = _L("MM-MMF-CTLFRM-U-0191");

  8192 	}

  8194 TVerdict CTestStep_MMF_CTLFRM_U_0191::DoTestStepL( void )

  8195 /**

  8196  * Use case: N/A

  8197  * @test Req. under test

  8198  */

  8199 	{

  8200 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8201 	__MM_HEAP_MARK;

  8203 	TVerdict verdict = EPass;

  8204 //	TMMFPrioritySettings settings;	//EABI warning removal

  8206 //	settings.iPriority = 1;

  8207 //	settings.iPref = EMdaPriorityPreferenceTime;

  8208 //	settings.iState = EMMFStateIdle;

  8210 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  8211 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8213 	CMMFFormatDecodePluginSelectionParameters* fDecodeSelect = CMMFFormatDecodePluginSelectionParameters::NewLC();

  8215 	// Set the format match data

  8216 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  8218 	// Set the controller plugin play format match data

  8219 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  8220 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  8222 	fDecodeSelect->SetRequiredFormatSupportL(*fSelect);

  8224 	fDecodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  8226 	//---------------------//

  8228 	// Get Decode Format(s)

  8229 	RMMFFormatImplInfoArray formats;

  8230 	CleanupResetAndDestroyPushL(formats);

  8231 	fDecodeSelect->ListImplementationsL(formats);

  8234 	RArray<TUid> mediaIds;

  8236 	//---------------------//

  8237 	// Method being Tested //

  8238 	//---------------------//

  8239 	fDecodeSelect->SetMediaIdsL(mediaIds, CMMFPluginSelectionParameters::EAllowOnlySuppliedMediaIds);

  8240 	//---------------------//

  8242 	TUid uid = {0x101FF9FF};

  8244 	if (mediaIds.Count() > 0)

  8245 		{

  8246 		if (mediaIds[0] == uid)

  8247 			{

  8248 			verdict = EPass;

  8249 			}

  8250 		}

  8251 	else

  8252 		{

  8253 		verdict = EFail;

  8254 		}

  8256 	// Check the Uid is correct, hense the correct interface has been obtained

  8257 	TUid formatUid;

  8258 	formatUid = formats[0]->Uid();

  8259 	if (formatUid == KMmfUidFormatPAVReadUid)

  8260 		{

  8261 		verdict = EPass;

  8262 		}

  8263 	else

  8264 		{

  8265 		verdict = EFail;

  8266 		}

  8268 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fDecodeSelect

  8270 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  8271 	__MM_HEAP_MARKEND;

  8273 	return verdict;

  8274 	}

  8276 //---------------------------------------------------------------

  8279 CTestStep_MMF_CTLFRM_U_0192::CTestStep_MMF_CTLFRM_U_0192()

  8280 	/** Constructor

  8281 	*/

  8282 	{

  8283 	// store the name of this test case

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

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

  8286 	iTestStepName = _L("MM-MMF-CTLFRM-U-0192");

  8289 	}

  8291 TVerdict CTestStep_MMF_CTLFRM_U_0192::DoTestStepL( void )

  8292 /**

  8293  * Use case: N/A

  8294  * @test Req. under test

  8295  */

  8296 	{

  8297 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8298 	__MM_HEAP_MARK;

  8300 	TVerdict verdict = EPass;

  8301 	_LIT(KExpectedText, "Symbian");

  8303 //	TMMFPrioritySettings settings;	//EABI warning removal

  8305 //	settings.iPriority = 1;

  8306 //	settings.iPref = EMdaPriorityPreferenceTime;

  8307 //	settings.iState = EMMFStateIdle;

  8309 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  8310 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8312 	CMMFFormatDecodePluginSelectionParameters* fDecodeSelect = CMMFFormatDecodePluginSelectionParameters::NewLC();

  8314 	// Set the format match data

  8315 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  8317 	// Set the controller plugin play format match data

  8318 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  8319 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  8321 	fDecodeSelect->SetRequiredFormatSupportL(*fSelect);

  8323 	fDecodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  8324 	//---------------------//

  8326 	// Get Decode Format(s)

  8327 	RMMFFormatImplInfoArray formats;

  8328 	CleanupResetAndDestroyPushL(formats);

  8329 	fDecodeSelect->ListImplementationsL(formats);

  8331 	//---------------------//

  8332 	// Method being Tested //

  8333 	//---------------------//

  8334 	TBufC<12> bufC = fDecodeSelect->PreferredSupplier();

  8335 	//---------------------//

  8337 	if ((bufC == KExpectedText) && (verdict == EPass))

  8338 		{

  8339 		verdict = EPass;

  8340 		}

  8341 	else

  8342 		{

  8343 		verdict = EFail;

  8344 		}

  8346 	// Check the Uid is correct, hense the correct interface has been obtained

  8347 	TUid formatUid;

  8348 	formatUid = formats[0]->Uid();

  8349 	if (formatUid == KMmfUidFormatPAVReadUid && verdict == EPass)

  8350 		{

  8351 		verdict = EPass;

  8352 		}

  8353 	else

  8354 		{

  8355 		verdict = EFail;

  8356 		}

  8358 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fDecodeSelect

  8360 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  8361 	__MM_HEAP_MARKEND;

  8363 	return verdict;

  8364 	}

  8366 //---------------------------------------------------------------

  8369 CTestStep_MMF_CTLFRM_U_0193::CTestStep_MMF_CTLFRM_U_0193()

  8370 	/** Constructor

  8371 	*/

  8372 	{

  8373 	// store the name of this test case

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

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

  8376 	iTestStepName = _L("MM-MMF-CTLFRM-U-0193");

  8379 	}

  8381 TVerdict CTestStep_MMF_CTLFRM_U_0193::DoTestStepL( void )

  8382 /**

  8383  * Use case: N/A

  8384  * @test Req. under test

  8385  */

  8386 	{

  8387 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8388 	__MM_HEAP_MARK;

  8390 	TVerdict verdict = EPass;

  8391 //	TMMFPrioritySettings settings;	//EABI warning removal

  8394 //	settings.iPriority = 1;

  8395 //	settings.iPref = EMdaPriorityPreferenceTime;

  8396 //	settings.iState = EMMFStateIdle;

  8398 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  8399 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8401 	CMMFFormatDecodePluginSelectionParameters* fDecodeSelect = CMMFFormatDecodePluginSelectionParameters::NewLC();

  8403 	// Set the format match data

  8404 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  8406 	// Set the controller plugin play format match data

  8407 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  8408 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  8410 	fDecodeSelect->SetRequiredFormatSupportL(*fSelect);

  8412 	fDecodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  8413 	//---------------------//

  8415 	// Get Decode Format(s)

  8416 	RMMFFormatImplInfoArray formats;

  8417 	CleanupResetAndDestroyPushL(formats);

  8418 	fDecodeSelect->ListImplementationsL(formats);

  8420 	//---------------------//

  8421 	// Method being Tested //

  8422 	//---------------------//

  8423 	if ((fDecodeSelect->PreferredSupplierMatchType() == CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned) && (verdict == EPass))

  8424 		{

  8425 		verdict = EPass;

  8426 		}

  8427 	else

  8428 		{

  8429 		verdict = EFail;

  8430 		}

  8431 	//---------------------//

  8433 	// Check the Uid is correct, hense the correct interface has been obtained

  8434 	TUid formatUid;

  8435 	formatUid = formats[0]->Uid();

  8436 	if (formatUid == KMmfUidFormatPAVReadUid && verdict == EPass)

  8437 		{

  8438 		verdict = EPass;

  8439 		}

  8440 	else

  8441 		{

  8442 		verdict = EFail;

  8443 		}

  8445 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fDecodeSelect

  8447 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  8448 	__MM_HEAP_MARKEND;

  8450 	return verdict;

  8451 	}

  8453 //---------------------------------------------------------------

  8456 CTestStep_MMF_CTLFRM_U_0194::CTestStep_MMF_CTLFRM_U_0194()

  8457 	/** Constructor

  8458 	*/

  8459 	{

  8460 	// store the name of this test case

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

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

  8463 	iTestStepName = _L("MM-MMF-CTLFRM-U-0194");

  8466 	}

  8468 TVerdict CTestStep_MMF_CTLFRM_U_0194::DoTestStepL( void )

  8469 /**

  8470  * Use case: N/A

  8471  * @test Req. under test

  8472  */

  8473 	{

  8474 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8475 	__MM_HEAP_MARK;

  8477 	TVerdict verdict = EPass;

  8478 //	TMMFPrioritySettings settings;	//EABI warning removal

  8481 //	settings.iPriority = 1;

  8482 //	settings.iPref = EMdaPriorityPreferenceTime;

  8483 //	settings.iState = EMMFStateIdle;

  8485 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  8486 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8488 	CMMFFormatDecodePluginSelectionParameters* fDecodeSelect = CMMFFormatDecodePluginSelectionParameters::NewLC();

  8490 	// Set the format match data

  8491 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  8493 	// Set the controller plugin play format match data

  8494 	cSelect->SetRequiredRecordFormatSupportL(*fSelect);

  8495 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  8497 	fDecodeSelect->SetRequiredFormatSupportL(*fSelect);

  8499 	fDecodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  8500 	//---------------------//

  8502 	// Get Decode Format(s)

  8503 	RMMFFormatImplInfoArray formats;

  8504 	CleanupResetAndDestroyPushL(formats);

  8505 	fDecodeSelect->ListImplementationsL(formats);

  8507 	TUid testUid = {0x12345679};

  8508 	RArray<TUid> mediaIdsToAdd;

  8509 	mediaIdsToAdd.Append(testUid);

  8511 	fDecodeSelect->SetMediaIdsL(mediaIdsToAdd, CMMFPluginSelectionParameters::EAllowOtherMediaIds);

  8513 	//---------------------//

  8514 	// Method being Tested //

  8515 	//---------------------//

  8516 	const RArray<TUid>& mediaIds = fDecodeSelect->MediaIds();

  8517 	//---------------------//

  8519 	if (mediaIds.Count() > 0)

  8520 		{

  8521 		TUid uid = {0x12345679};

  8522 		if (mediaIds[0] == uid)

  8523 			{

  8524 			verdict = EPass;

  8525 			}

  8526 		else

  8527 			{

  8528 			verdict = EFail;

  8529 			}

  8530 		}

  8531 	else

  8532 		{

  8533 		verdict = EFail;

  8534 		}

  8536 	// Check the Uid is correct, hense the correct interface has been obtained

  8537 	TUid formatUid;

  8538 	formatUid = formats[0]->Uid();

  8539 	if (formatUid == KMmfUidFormatPAVReadUid && verdict == EPass)

  8540 		{

  8541 		verdict = EPass;

  8542 		}

  8543 	else

  8544 		{

  8545 		verdict = EFail;

  8546 		}

  8548 	mediaIdsToAdd.Remove(0); // Remove otherwise TUid will be destroyed below and Panic.

  8549 	mediaIdsToAdd.Close();

  8551 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fDecodeSelect

  8553 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  8554 	__MM_HEAP_MARKEND;

  8556 	return verdict;

  8557 	}

  8559 //---------------------------------------------------------------

  8561 CTestStep_MMF_CTLFRM_U_0195::CTestStep_MMF_CTLFRM_U_0195()

  8562 	/** Constructor

  8563 	*/

  8564 	{

  8565 	// store the name of this test case

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

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

  8568 	iTestStepName = _L("MM-MMF-CTLFRM-U-0195");

  8571 	}

  8573 TVerdict CTestStep_MMF_CTLFRM_U_0195::DoTestStepL( void )

  8574 /**

  8575  * Use case: N/A

  8576  * @test Req. under test

  8577  */

  8578 	{

  8579 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8580 	__MM_HEAP_MARK;

  8582 	TVerdict verdict = EPass;

  8584 //	TMMFPrioritySettings settings;	//EABI warning removal

  8586 //	settings.iPriority = 1;

  8587 //	settings.iPref = EMdaPriorityPreferenceTime;

  8588 //	settings.iState = EMMFStateIdle;

  8590 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  8591 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8593 	CMMFFormatDecodePluginSelectionParameters* fDecodeSelect = CMMFFormatDecodePluginSelectionParameters::NewLC();

  8595 	// Set the format match data

  8596 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  8598 	// Set the controller plugin play format match data

  8599 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  8600 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  8602 	fDecodeSelect->SetRequiredFormatSupportL(*fSelect);

  8604 	fDecodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  8605 	//---------------------//

  8607 	// Get Decode Format(s)

  8608 	RMMFFormatImplInfoArray formats;

  8609 	CleanupResetAndDestroyPushL(formats);

  8610 	fDecodeSelect->ListImplementationsL(formats);

  8612 	//---------------------//

  8613 	// Method being Tested //

  8614 	//---------------------//

  8616 	if ((fDecodeSelect->MediaIdMatchType() == CMMFPluginSelectionParameters::ENoMediaIdMatch) && (verdict == EPass))

  8617 		{

  8618 		verdict = EPass;

  8619 		}

  8620 	else

  8621 		{

  8622 		verdict = EFail;

  8623 		}

  8624 	//---------------------//

  8626 	// Check the Uid is correct, hense the correct interface has been obtained

  8627 	TUid formatUid;

  8628 	formatUid = formats[0]->Uid();

  8629 	if (formatUid == KMmfUidFormatPAVReadUid && verdict == EPass)

  8630 		{

  8631 		verdict = EPass;

  8632 		}

  8633 	else

  8634 		{

  8635 		verdict = EFail;

  8636 		}

  8638 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fDecodeSelect

  8640 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  8641 	__MM_HEAP_MARKEND;

  8643 	return verdict;

  8644 	}

  8646 //---------------------------------------------------------------

  8648 CTestStep_MMF_CTLFRM_U_0196::CTestStep_MMF_CTLFRM_U_0196()

  8649 	/** Constructor

  8650 	*/

  8651 	{

  8652 	// store the name of this test case

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

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

  8655 	iTestStepName = _L("MM-MMF-CTLFRM-U-0196");

  8658 	}

  8660 TVerdict CTestStep_MMF_CTLFRM_U_0196::DoTestStepL( void )

  8661 /**

  8662  * Use case: N/A

  8663  * @test Req. under test

  8664  */

  8665 	{

  8666 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8667 	__MM_HEAP_MARK;

  8669 	TVerdict verdict = EPass;

  8670 //	TMMFPrioritySettings settings;	//EABI warning removal

  8672 //	settings.iPriority = 1;

  8673 //	settings.iPref = EMdaPriorityPreferenceTime;

  8674 //	settings.iState = EMMFStateIdle;

  8676 	CMMFControllerPluginSelectionParameters* cSelect = CMMFControllerPluginSelectionParameters::NewLC();

  8677 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8679 	CMMFFormatDecodePluginSelectionParameters* fDecodeSelect = CMMFFormatDecodePluginSelectionParameters::NewLC();

  8681 	// Set the format match data

  8682 	fSelect->SetMatchToFileNameL(_L("test.pav"));

  8684 	// Set the controller plugin play format match data

  8685 	cSelect->SetRequiredPlayFormatSupportL(*fSelect);

  8686 	cSelect->SetPreferredSupplierL(KTestControllerSupplier, CMMFPluginSelectionParameters::EPreferredSupplierPluginsFirstInList);

  8688 	fDecodeSelect->SetRequiredFormatSupportL(*fSelect);

  8690 	fDecodeSelect->SetPreferredSupplierL(_L("Symbian"),CMMFPluginSelectionParameters::EOnlyPreferredSupplierPluginsReturned);

  8691 	//---------------------//

  8693 	// Get Decode Format(s)

  8694 	RMMFFormatImplInfoArray formats;

  8695 	CleanupResetAndDestroyPushL(formats);

  8696 	fDecodeSelect->ListImplementationsL(formats);

  8698 	//---------------------//

  8699 	// Method being Tested //

  8700 	//---------------------//

  8701 	TUid uid = fDecodeSelect->InterfaceUid();

  8702 	//---------------------//

  8704 	if (uid == KMmfUidPluginInterfaceFormatDecodeUid)

  8705 		{

  8706 		verdict = EPass;

  8707 		}

  8708 	else

  8709 		{

  8710 		verdict = EFail;

  8711 		}

  8714 	// Check the Uid is correct, hense the correct interface has been obtained

  8715 	TUid formatUid;

  8716 	formatUid = formats[0]->Uid();

  8717 	if (formatUid == KMmfUidFormatPAVReadUid && verdict == EPass)

  8718 		{

  8719 		verdict = EPass;

  8720 		}

  8721 	else

  8722 		{

  8723 		verdict = EFail;

  8724 		}

  8726 	CleanupStack::PopAndDestroy(4);//formats, fSelect, cSelect, fDecodeSelect

  8728 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  8729 	__MM_HEAP_MARKEND;

  8731 	return verdict;

  8732 	}

  8734 //---------------------------------------------------------------

  8736 CTestStep_MMF_CTLFRM_U_0125::CTestStep_MMF_CTLFRM_U_0125()

  8737 	/** Constructor

  8738 	*/

  8739 	{

  8740 	// store the name of this test case

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

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

  8743 	iTestStepName = _L("MM-MMF-CTLFRM-U-0125");

  8746 	}

  8748 TVerdict CTestStep_MMF_CTLFRM_U_0125::DoTestStepL( void )

  8749 /** Instantiate a CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParameters

  8750  *  set the parameters appropiately (See API Method Calls and Parameters) to obtain

  8751  *  controller Implementation Uid's in a CMMFControllerImplementationInformation Array to

  8752  *  open a controller. Open the controller, check for errors and close the controller.

  8753  *  (Test CMMFFormatSelectionParameters API).

  8755  * Use case: N/A

  8756  * @test Req. under test REQ172.5.5 REQ172.5.5.13

  8757  */

  8758 	{

  8759 	const TInt KNumberTestURIs = 5;

  8760 	_LIT(KTestUri1,"rtsp://www.symbian.com/first/test/directory/test.rm");

  8761 	_LIT(KTestUri2,"www.symbian.com/first/test/directory/test.rm#garbage characters");

  8762 	_LIT(KTestUri3,"rtsp://www.symbian.com/first/test/directory/test.rm?param=22050&cat=find");

  8763 	_LIT(KTestUri4,"rtsp://www.symbian.com/first/test/directory/test.rm?param=22050&cat=find#garbage characters at end of url");

  8764 	_LIT(KTestUri5,"rtsp://194.252.88.2:554/yle24/mobile/uusin.rm?cloakport=\"80,554,7");

  8765 	_LIT8(KExpectedMatchData,".rm");

  8768 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8769 	__MM_HEAP_MARK;

  8771 	TVerdict verdict = EPass;

  8773 	TPtrC testURIs[KNumberTestURIs];

  8774 	TPtrC8 expectedMatchData[KNumberTestURIs];

  8775 	testURIs[0].Set(KTestUri1);

  8776 	testURIs[1].Set(KTestUri2);

  8777 	testURIs[2].Set(KTestUri3);

  8778 	testURIs[3].Set(KTestUri4);

  8779 	testURIs[4].Set(KTestUri5);

  8781 	expectedMatchData[0].Set(KExpectedMatchData);

  8782 	expectedMatchData[1].Set(KExpectedMatchData);

  8783 	expectedMatchData[2].Set(KExpectedMatchData);

  8784 	expectedMatchData[3].Set(KExpectedMatchData);

  8785 	expectedMatchData[4].Set(KExpectedMatchData);

  8787 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8789 	// Set the format match data

  8790 	for (TInt i=0;i<KNumberTestURIs;i++)

  8791 		{

  8792 		//---------------------//

  8793 		// Method being Tested //

  8794 		//---------------------//

  8795 		fSelect->SetMatchToUriL(testURIs[i]);

  8796 		//---------------------//

  8798  		if (fSelect->MatchDataType() == CMMFFormatSelectionParameters::EMatchFileExtension)

  8799 			{

  8800 			const TDesC8& matchData = fSelect->MatchData();

  8802 			// make a unicode copy of the match data (file extension) for printing out

  8803 			HBufC* bufMatchData = HBufC::NewL(matchData.Length());

  8805 			TPtr ptr = bufMatchData->Des();

  8806 			ptr.Copy(matchData);

  8807 			if (!(matchData == expectedMatchData[i]))

  8808 				{

  8809 				INFO_PRINTF3(_L("Uri Match Data failed on URI: %S | extension: %S"),

  8810 								&testURIs[i],

  8811 								bufMatchData);

  8812 				verdict = EFail;

  8813 				} else {

  8815 				INFO_PRINTF3(_L("Success  URI: %S | extension: %S"),

  8816 								&testURIs[i],

  8817 								bufMatchData);

  8819 				}

  8820 			delete bufMatchData;

  8822 			}

  8823 		else

  8824 			{

  8825   			INFO_PRINTF1(_L("MatchDataType set to incorrect type (should be EMatchFileExtension)"));

  8826   			verdict = EFail;

  8827 			}

  8828 		}

  8830 	CleanupStack::Pop(fSelect);

  8833 	return verdict;

  8834 	}

  8837 //------------------------------------------------------------------

  8839 //---------------------------------------------------------------

  8841 CTestStep_MMF_CTLFRM_U_0198::CTestStep_MMF_CTLFRM_U_0198()

  8842 	/** Constructor

  8843 	*/

  8844 	{

  8845 	// store the name of this test case

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

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

  8848 	iTestStepName = _L("MM-MMF-CTLFRM-U-0198");

  8851 	}

  8853 TVerdict CTestStep_MMF_CTLFRM_U_0198::DoTestStepL( void )

  8854 /** Instantiate a CMMFControllerPluginSelectionParameters and CMMFFormatSelectionParameters

  8855  *  set the parameters appropiately (See API Method Calls and Parameters) to obtain

  8856  *  controller Implementation Uid's in a CMMFControllerImplementationInformation Array to

  8857  *  open a controller. Open the controller, check for errors and close the controller.

  8858  *  (Test CMMFFormatSelectionParameters API).

  8860  * Use case: N/A

  8861  * @test Req. under CR0632

  8862  */

  8863 	{

  8864 	const TInt KNumberTestURIs = 5;

  8865 	_LIT(KTestUri1,"rtsp://www.symbian.com/first/test/directory/test.rm");

  8866 	_LIT(KTestUri2,"www.symbian.com/first/test/directory/test.rm#garbage characters");

  8867 	_LIT(KTestUri3,"rtsp://www.symbian.com/first/test/directory/test.rm?param=22050&cat=find");

  8868 	_LIT(KTestUri4,"rtsp://www.symbian.com/first/test/directory/test.rm?param=22050&cat=find#garbage characters at end of url");

  8869 	_LIT(KTestUri5,"rtsp://194.252.88.2:554/yle24/mobile/uusin.rm?cloakport=\"80,554,7");

  8870 	_LIT8(KExpectedMatchData,"rtsp");

  8871 	_LIT8(KExpectedMatchData2,"");

  8873 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8874 	__MM_HEAP_MARK;

  8876 	TVerdict verdict = EPass;

  8878 	TPtrC testURIs[KNumberTestURIs];

  8879 	TPtrC8 expectedMatchData[KNumberTestURIs];

  8880 	testURIs[0].Set(KTestUri1);

  8881 	testURIs[1].Set(KTestUri2);

  8882 	testURIs[2].Set(KTestUri3);

  8883 	testURIs[3].Set(KTestUri4);

  8884 	testURIs[4].Set(KTestUri5);

  8886 	expectedMatchData[0].Set(KExpectedMatchData);

  8887 	expectedMatchData[1].Set(KExpectedMatchData2);

  8888 	expectedMatchData[2].Set(KExpectedMatchData);

  8889 	expectedMatchData[3].Set(KExpectedMatchData);

  8890 	expectedMatchData[4].Set(KExpectedMatchData);

  8892 	CMMFFormatSelectionParameters* fSelect = CMMFFormatSelectionParameters::NewLC();

  8894 	// Set the format match data

  8895 	for (TInt i=0;i<KNumberTestURIs;i++)

  8896 		{

  8897 		//---------------------//

  8898 		// Method being Tested //

  8899 		//---------------------//

  8900 		fSelect->SetMatchToUriSupportL(testURIs[i]);

  8901 		//---------------------//

  8903  		if (fSelect->MatchDataType() == CMMFFormatSelectionParameters::EMatchUri)

  8904 			{

  8905 			const TDesC8& matchurischeme = fSelect->MatchUriScheme();

  8907 			HBufC* bufMatchData = HBufC::NewL(matchurischeme.Length());

  8909 			TPtr ptr = bufMatchData->Des();

  8910 			ptr.Copy(matchurischeme);

  8911 			if (!(matchurischeme == expectedMatchData[i]))

  8912 				{

  8913 				INFO_PRINTF3(_L("Uri Match Data failed on URI: %S | scheme: %S"),

  8914 								&testURIs[i],

  8915 								bufMatchData);

  8916 				verdict = EFail;

  8917 				} else {

  8919 				INFO_PRINTF3(_L("Success  URI: %S | scheme: %S"),

  8920 								&testURIs[i],

  8921 								bufMatchData);

  8923 				}

  8924 			delete bufMatchData;

  8926 			}

  8927 		else

  8928 			{

  8929   			INFO_PRINTF1(_L("MatchDataType set to incorrect type (should be EMatchUri)"));

  8930   			verdict = EFail;

  8931 			}

  8932 		}

  8934 	CleanupStack::Pop(fSelect);

  8937 	return verdict;

  8938 	}

  8941 #ifdef SYMBIAN_BUILD_GCE

  8942 //---------------------------------------------------------------------

  8943 // Testing of the Standard Custom Commands of video surface support

  8944 //----------------------------------------------------------------------

  8946 CTestStep_MMF_CTLFRM_U_0301::CTestStep_MMF_CTLFRM_U_0301()

  8947 	/** Constructor

  8948 	*/

  8949 	{

  8950 	// store the name of this test case

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

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

  8953 	iTestStepName = _L("MM-MMF-CTLFRM-U-0301");

  8954 	}

  8956 TVerdict CTestStep_MMF_CTLFRM_U_0301::DoTestStepL( void )

  8957 /** Call the RMMFController::Open(..) (with the parameters from test 001), varify the

  8958  *  return value is 0. Instantiate a CustomCommands Object (specified). Call

  8959  *  RMMFVideoPlaySurfaceSupportCustomCommands Method specified and varify the 'error'

  8960  *  is 0. Follow this by calling the  Custom Command 'KLogFunction' and varify the text

  8961  *  value returned is equal to the specifed text in Test Step. Call the RMMFController::Close()

  8962  *  on the Custom Controller. Varify 'error' is zero.

  8964  * Use case: N/A

  8965  * @test Req. under test REQ 7418

  8966  */

  8967 	{

  8968 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  8969 	__MM_HEAP_MARK;

  8971 	TVerdict verdict = EPass;

  8972 	_LIT8(KExpectedResult, "MvpssUseSurfacesL Called");

  8974 	TMMFPrioritySettings settings;

  8975 	TInt error = KErrNone;

  8976 	RMMFController controller;

  8978 	settings.iPriority = 1;

  8979 	settings.iPref = EMdaPriorityPreferenceTime;

  8980 	settings.iState = EMMFStateIdle;

  8982 	// Open a Custom Controller

  8983 	error = controller.Open(KTstControllerUid,settings);

  8984 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  8986 	if (error == KErrNone)

  8987 		{

  8988 		RMMFVideoPlaySurfaceSupportCustomCommands customCommands(controller);

  8990 		error = customCommands.UseSurfaces();

  8991 		INFO_PRINTF2(_L("customCommands.UseSurfaces() returns: %d"), error);

  8992 		}

  8993 	//------------------------------------//

  8994 	// Getting Log from Custom Controller //

  8995 	//------------------------------------//

  8996 	if (error == KErrNone)

  8997 		{

  8998 		INFO_PRINTF1(_L("Getting Log"));

  9000 		TBuf8<64> memFunctionText;

  9002 		TUid uid = {KMmfTestControllerUid};

  9003 		TMMFMessageDestination handleInfo(uid);

  9004 		TMMFMessageDestinationPckg messageDest(handleInfo);

  9006 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  9008 		TBuf<64> memFunctionText16;

  9009 		memFunctionText16.Copy(memFunctionText);

  9010 	 	INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  9012 		if (memFunctionText != KExpectedResult)

  9013 			{

  9014 			verdict = EFail;

  9015 			}

  9017 		}

  9018 	//------------------------------------//

  9020 	if (error != KErrNone)

  9021 		{

  9022 		INFO_PRINTF2(_L("Test case failed with error:%d"),error);

  9023 		verdict = EFail;

  9024 		}

  9027 	INFO_PRINTF1(_L("Closing Controller"));

  9028 	controller.Close();

  9030 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  9031 	__MM_HEAP_MARKEND;

  9033 	return verdict;

  9034 	}

  9036 //---------------------------------------------------------------

  9038 CTestStep_MMF_CTLFRM_U_0303::CTestStep_MMF_CTLFRM_U_0303()

  9039 	/** Constructor

  9040 	*/

  9041 	{

  9042 	// store the name of this test case

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

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

  9046 	iTestStepName = _L("MM-MMF-CTLFRM-U-0303");

  9047 	}

  9049 TVerdict CTestStep_MMF_CTLFRM_U_0303::DoTestStepL( void )

  9050 /** As TSU_MMF_CTLFRM_U_0301

  9052  * Use case: N/A

  9053  * @test Req. under test REQ1714.3.3

  9054  */

  9055 	{

  9056 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  9057 	__MM_HEAP_MARK;

  9059 	TVerdict verdict = EPass;

  9060 	_LIT8(KExpectedResult, "MvpssGetSurfaceParametersL Called");

  9062 	TMMFPrioritySettings settings;

  9063 	TInt error = KErrNone;

  9064 	RMMFController controller;

  9066 	settings.iPriority = 1;

  9067 	settings.iPref = EMdaPriorityPreferenceTime;

  9068 	settings.iState = EMMFStateIdle;

  9070 	TSurfaceId surfaceId;

  9071 	TRect getRect;

  9072 	TVideoAspectRatio par;

  9074 	// Open a Custom Controller

  9075 	error = controller.Open(KTstControllerUid,settings);

  9076 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  9078 	if (error == KErrNone)

  9079 		{

  9080 		RMMFVideoPlaySurfaceSupportCustomCommands customCommands(controller);

  9082 		error = customCommands.GetSurfaceParameters(surfaceId, getRect,par);

  9083 		INFO_PRINTF2(_L("customCommands.GetSurfaceParameters returns: %d"), error);

  9084 		}

  9086 	//From mmf test controller which sets the values

  9087 	TSurfaceId expectedSurfaceId = {11111, 22222, 33333, 44444};

  9088 	TInt expectedTlIx = 100;

  9089 	TInt expectedTlIy = 50;

  9090 	TInt expectedBrIx = 600;

  9091 	TInt expectedBrIy = 200;

  9092 	TInt expectedParIN = 1;

  9093 	TInt expectedParID = 2;

  9096 	//------------------------------------//

  9097 	// Getting Log from Custom Controller //

  9098 	//------------------------------------//

  9099 	if (!error)

  9100 		{

  9101 		INFO_PRINTF1(_L("Getting Log"));

  9103 		TBuf8<64> memFunctionText;

  9105 		TUid uid = {KMmfTestControllerUid};

  9106 		TMMFMessageDestination handleInfo(uid);

  9107 		TMMFMessageDestinationPckg messageDest(handleInfo);

  9109 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  9111 		TBuf<64> memFunctionText16;

  9112 		memFunctionText16.Copy(memFunctionText);

  9113 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  9115 		if (memFunctionText != KExpectedResult || expectedSurfaceId != surfaceId || expectedTlIx != getRect.iTl.iX ||

  9116 			expectedTlIy != getRect.iTl.iY || expectedBrIx != getRect.iBr.iX || expectedBrIy != getRect.iBr.iY ||

  9117 			expectedParIN != par.iNumerator || expectedParID != par.iDenominator)

  9118 			{

  9119 			INFO_PRINTF5(_L("Expected surfaceId %d %d %d %d"),

  9120 							expectedSurfaceId.iInternal[0], expectedSurfaceId.iInternal[1],

  9121 							expectedSurfaceId.iInternal[2], expectedSurfaceId.iInternal[3]);

  9122 			INFO_PRINTF5(_L("surfaceId Available %d %d %d %d"),

  9123 							surfaceId.iInternal[0], surfaceId.iInternal[1],

  9124 							surfaceId.iInternal[2], surfaceId.iInternal[3]);

  9125 			INFO_PRINTF2(_L("Expected Rect first %d"),expectedTlIx);

  9126 			INFO_PRINTF2(_L("Rect first Available %d"),getRect.iTl.iX);

  9127 			INFO_PRINTF2(_L("Expected Rect second %d"),expectedTlIy);

  9128 			INFO_PRINTF2(_L("Rect second Available %d"),getRect.iTl.iY);

  9129 			INFO_PRINTF2(_L("Expected Rect third %d"),expectedBrIx);

  9131 			INFO_PRINTF2(_L("Rect third Available %d"),getRect.iBr.iX);

  9132 			INFO_PRINTF2(_L("Expected Rect fourth %d"),expectedBrIy);

  9133 			INFO_PRINTF2(_L("Rect fourth Available %d"),getRect.iBr.iY);

  9134 			INFO_PRINTF2(_L("Expected TVideoAspectRatio iNumerator %d"),expectedParIN);

  9135 			INFO_PRINTF2(_L("TVideoAspectRatio iNumerator Available %d"),par.iNumerator);

  9136 			INFO_PRINTF2(_L("Expected TVideoAspectRatio iDenominator %d"),expectedParID);

  9137 			INFO_PRINTF2(_L("TVideoAspectRatio iDenominator Available %d"),par.iDenominator);

  9139 			verdict = EFail;

  9140 			}

  9142 		}

  9143 	//------------------------------------//

  9145 	INFO_PRINTF1(_L("Closing Controller"));

  9146 	controller.Close();

  9148 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  9149 	__MM_HEAP_MARKEND;

  9151 	return verdict;

  9152 	}

  9154 //---------------------------------------------------------------

  9156 CTestStep_MMF_CTLFRM_U_0305::CTestStep_MMF_CTLFRM_U_0305(TSurfaceId& aSurfaceId, TBool aNegTest)

  9157 	/** Constructor

  9158 	*/

  9159 	{

  9160 	// store the name of this test case

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

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

  9163 	iNegTest = aNegTest;

  9165 	if (!aNegTest) // The value for the positive testing in test controller

  9166 		{

  9167 		iSurfaceId = aSurfaceId;

  9168 		iTestStepName = _L("MM-MMF-CTLFRM-U-0305");

  9169 		}

  9170 	else  // Any other value for the negative testing

  9171 		{

  9172 		iSurfaceId2 = aSurfaceId;

  9173 		iTestStepName = _L("MM-MMF-CTLFRM-U-0309");

  9174 		}

  9175 	}

  9177 TVerdict CTestStep_MMF_CTLFRM_U_0305::DoTestStepL()

  9178 /** As TSU_MMF_CTLFRM_U_0301

  9179  * Use case: N/A

  9180  * @test Req. under test REQ 7418

  9181  */

  9182 	{

  9183 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  9184 	__MM_HEAP_MARK;

  9186 	TVerdict verdict = EPass;

  9187 	_LIT8(KExpectedResult, "MvpssSurfaceRemovedL Called");

  9189 	TMMFPrioritySettings settings;

  9190 	TInt error = KErrNone;

  9191 	RMMFController controller;

  9193 	settings.iPriority = 1;

  9194 	settings.iPref = EMdaPriorityPreferenceTime;

  9195 	settings.iState = EMMFStateIdle;

  9197 	// Open a Custom Controller

  9198 	error = controller.Open(KTstControllerUid,settings);

  9199 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  9201 	TSurfaceId surfaceId;

  9202 	if(iNegTest)

  9203 		{

  9204 		surfaceId = iSurfaceId2;

  9205 		}

  9206 	else

  9207 		{

  9208 		surfaceId = iSurfaceId;

  9209 		}

  9211 	if (error == KErrNone)

  9212 		{

  9213 		RMMFVideoPlaySurfaceSupportCustomCommands customCommands(controller);

  9214 		error = customCommands.SurfaceRemoved(surfaceId);

  9215 		INFO_PRINTF2(_L("customCommands.SurfaceRemoved returns: %d"), error);

  9216 		}

  9218 	//------------------------------------//

  9219 	// Getting Log from Custom Controller //

  9220 	//------------------------------------//

  9221 	if (error == KErrNone)

  9222 		{

  9223 		INFO_PRINTF1(_L("Getting Log"));

  9225 		TBuf8<64> memFunctionText;

  9227 		TUid uid = {KMmfTestControllerUid};

  9228 		TMMFMessageDestination handleInfo(uid);

  9229 		TMMFMessageDestinationPckg messageDest(handleInfo);

  9231 		error = controller.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  9233 		TBuf<64> memFunctionText16;

  9234 		memFunctionText16.Copy(memFunctionText);

  9235 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  9237 		if (memFunctionText != KExpectedResult)

  9238 			{

  9239 			verdict = EFail;

  9240 			}

  9241 		}

  9243 	if (error != KErrNone)

  9244 		{

  9245 		if (iNegTest && error == KErrArgument)

  9246 			{

  9247 			INFO_PRINTF1(_L("Negative test; Expected return with -6"));

  9248 			verdict = EPass;

  9249 			}

  9250 		else

  9251 			{

  9252 			INFO_PRINTF2(_L("Failed with error:%d"),error);

  9253 			verdict = EFail;

  9254 			}

  9255 		}

  9257 	if (iNegTest && error != KErrArgument)

  9258 		{

  9259 		INFO_PRINTF1(_L("Negative test; Expected return with -6"));

  9260 		verdict = EFail;

  9261 		}

  9262 	//------------------------------------//

  9264 	INFO_PRINTF1(_L("Closing Controller"));

  9265 	controller.Close();

  9267 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  9268 	__MM_HEAP_MARKEND;

  9270 	return verdict;

  9271 	}

  9274 //------------------------------------------------------------------

  9276 #endif // SYMBIAN_BUILD_GCE

  9278 RTestStep_MMF_CTLFRM_U_0200::RTestStep_MMF_CTLFRM_U_0200()

  9279 	/** Constructor

  9280 	*/

  9281 	{

  9282 	// store the name of this test case

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

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

  9285 	iTestStepName = _L("MM-MMF-CTLFRM-U-0200");

  9286 	}

  9288 TInt RTestStep_MMF_CTLFRM_U_0200::Timeout(TAny* aArg)

  9289 	{

  9290 	RTestStep_MMF_CTLFRM_U_0200* arg = static_cast<RTestStep_MMF_CTLFRM_U_0200*>(aArg);

  9291 	arg->StopTest(KErrNone,EFail);

  9293 	return 0;

  9294 	}

  9296 void RTestStep_MMF_CTLFRM_U_0200::KickoffTestL()

  9297 /**

  9298  * Call the RMMFController::Open(..) with the parameters specified,

  9299  * verify the return value is 0. Sends an asynchronous custom command to the controller which generates a panic

  9300  * in the subthread, verify the return value is 0. Verify application thread terminates with KErrDied. (with Active Scheduler)

  9302  * Use case: N/A

  9303  * @test Req. INC108007

  9304  */

  9305 	{

  9306 	// Create an active object that will wrap the test execution

  9307 	iAsyncTest = new (ELeave) CAsyncTest(this);

  9308 	iAsyncTest->Start();

  9309 	}

  9311 void RTestStep_MMF_CTLFRM_U_0200::CloseTest()

  9312 	{

  9313 	if (iAsyncTest)

  9314 		{

  9315 		iAsyncTest->Cancel();

  9316 		delete iAsyncTest;

  9317 		}

  9318 	}

  9320 void RTestStep_MMF_CTLFRM_U_0200::OpeningController()

  9321 	{

  9322 	INFO_PRINTF1(_L("Attempting to Open Controller"));

  9323 	}

  9325 void RTestStep_MMF_CTLFRM_U_0200::OpenCompleted(TInt aError)

  9326 	{

  9327 	INFO_PRINTF2(_L("Controller Open: %d"), aError);

  9328 	}

  9330 void RTestStep_MMF_CTLFRM_U_0200::ClosingController()

  9331 	{

  9332 	INFO_PRINTF1(_L("Closing Controller"));

  9333 	}

  9335 void RTestStep_MMF_CTLFRM_U_0200::ClosingComplete()

  9336 	{

  9337 	INFO_PRINTF1(_L("Controller Closed"));

  9338 	}

  9340 void RTestStep_MMF_CTLFRM_U_0200::SendingCustomCommand()

  9341 	{

  9342 	INFO_PRINTF1(_L("Sending Panic custom command"));

  9343 	}

  9345 void RTestStep_MMF_CTLFRM_U_0200::CustomCommandSent(TInt aError)

  9346 	{

  9347 	INFO_PRINTF2(_L("Custom Command Sent: %d"), aError);

  9348 	}

  9350 void RTestStep_MMF_CTLFRM_U_0200::CancellingCustomCommand()

  9351 	{

  9352 	INFO_PRINTF1(_L("Cancelling Panic custom command"));

  9353 	}

  9355 void RTestStep_MMF_CTLFRM_U_0200::CustomCommandCancelled(TInt aError)

  9356 	{

  9357 	INFO_PRINTF2(_L("Custom Command Cancelled: %d"), aError);

  9358 	}

  9360 void RTestStep_MMF_CTLFRM_U_0200::TestError(TInt aError)

  9361 	{

  9362 	if(aError!=KErrServerTerminated)

  9363 		{

  9364 		StopTest(aError,EFail);

  9365 		}

  9366 	else

  9367 		{

  9368 		StopTest(EPass);

  9369 		}

  9370 	}

  9372 RTestStep_MMF_CTLFRM_U_0200::CAsyncTest::CAsyncTest(MMMF_CTRLFRM_U_0200_Observer* aObserver)

  9373 : CActive(EPriorityStandard)

  9374 	{

  9375 	iObserver = aObserver;

  9377 	CActiveScheduler::Add(this);

  9378 	}

  9380 RTestStep_MMF_CTLFRM_U_0200::CAsyncTest::~CAsyncTest()

  9381 	{

  9382 	Cancel();

  9384 	iObserver->ClosingController();

  9385 	iController.Close();

  9386 	iObserver->ClosingComplete();

  9387 	}

  9389 void RTestStep_MMF_CTLFRM_U_0200::CAsyncTest::Start()

  9390 	{

  9391 	TMMFPrioritySettings settings;

  9392 	TInt error = KErrNone;

  9394 	settings.iPriority = 1;

  9395 	settings.iPref = EMdaPriorityPreferenceTime;

  9396 	settings.iState = EMMFStateIdle;

  9398 	iObserver->OpeningController();

  9400 	// Open a Custom Controller

  9401 	error = iController.Open(KTestTerminationControllerUid,settings);

  9402 	iObserver->OpenCompleted(error);

  9404 	//------------------------------------//

  9405 	// Sending Panic Custom Command //

  9406 	//------------------------------------//

  9407 	if (!error)

  9408 		{

  9409 		iObserver->SendingCustomCommand();

  9410 		TMMFMessageDestination handleInfo(KTestTerminationControllerUid);

  9411 		iMessage = handleInfo;

  9413 		iController.CustomCommandAsync(iMessage, KDummyFunc1, KNullDesC8, KNullDesC8, iStatus);

  9414 		SetActive();

  9415 		}

  9416 	else

  9417 		iObserver->TestError(error);

  9418 	}

  9420 void RTestStep_MMF_CTLFRM_U_0200::CAsyncTest::RunL()

  9421 	{

  9422 	iObserver->CustomCommandSent(iStatus.Int());

  9423 	iObserver->TestError(iStatus.Int());

  9424 	}

  9426 TInt RTestStep_MMF_CTLFRM_U_0200::CAsyncTest::RunError(TInt aError)

  9427 	{

  9428 	return aError;

  9429 	}

  9431 void RTestStep_MMF_CTLFRM_U_0200::CAsyncTest::DoCancel()

  9432 	{

  9434 	}

  9437 //------------------------------------------------------------------

  9439 CTestStep_MMF_CTLFRM_U_0201::CTestStep_MMF_CTLFRM_U_0201()

  9440 	/** Constructor

  9441 	*/

  9442 	{

  9443 	// store the name of this test case

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

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

  9446 	iTestStepName = _L("MM-MMF-CTLFRM-U-0201");

  9449 	}

  9452 TVerdict CTestStep_MMF_CTLFRM_U_0201::DoTestStepL( void )

  9453 /**

  9454  * Call the RMMFController::Open(..) with the parameters specified,

  9455  * verify the return value is 0. Sends an asynchronous custom command to the controller which generates a panic

  9456  * in the subthread, verify the return value is 0. Close the controller after a timeout and

  9457  * verify application thread terminates with KErrDied. (without Active Scheduler)

  9459  * Use case: N/A

  9460  * @test Req. INC108007

  9461  */

  9462 	{

  9463 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  9464 	__MM_HEAP_MARK;

  9466 	TVerdict verdict = EPass;

  9468 	TMMFPrioritySettings settings;

  9469 	TInt error = KErrNone;

  9470 	RMMFController controller;

  9472 	settings.iPriority = 1;

  9473 	settings.iPref = EMdaPriorityPreferenceTime;

  9474 	settings.iState = EMMFStateIdle;

  9476 	error = controller.Open(KTestTerminationControllerUid,settings);

  9477 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  9479 	//------------------------------------//

  9480 	// Sending Panic Custom Command //

  9481 	//------------------------------------//

  9482 	if (!error)

  9483 		{

  9484 		TMMFMessageDestination handleInfo(KTestTerminationControllerUid);

  9485 		TMMFMessageDestinationPckg messageDest(handleInfo);

  9487 		TRequestStatus status;

  9488 		INFO_PRINTF1(_L("Sending Panic custom command"));

  9489 		controller.CustomCommandAsync(messageDest, KDummyFunc1, KNullDesC8, KNullDesC8, status);

  9491 		// Creation of a timeout timer

  9492 		RTimer timer;

  9493 		timer.CreateLocal();

  9494 		TRequestStatus timeout = KRequestPending;

  9495 		timer.After(timeout, 3000000);

  9497 		User::WaitForRequest(status, timeout);

  9498 		INFO_PRINTF3(_L("Status=[%d] Timeout[%d]"), status.Int(), timeout.Int());

  9499 		}

  9500 	//------------------------------------//

  9503 	INFO_PRINTF1(_L("Closing Controller"));

  9504 	controller.Close();

  9506 	// client thread should not panic as such.

  9507 	verdict = EPass;

  9509 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  9510 	__MM_HEAP_MARKEND;

  9512 	return verdict;

  9513 	}

  9515 //------------------------------------------------------------------

  9517 CTestStep_MMF_CTLFRM_U_0202::CTestStep_MMF_CTLFRM_U_0202()

  9518 	/** Constructor

  9519 	*/

  9520 	{

  9521 	// store the name of this test case

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

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

  9524 	iTestStepName = _L("MM-MMF-CTLFRM-U-0202");

  9527 	}

  9530 TVerdict CTestStep_MMF_CTLFRM_U_0202::DoTestStepL( void )

  9531 /**

  9532  * Call the RMMFController::Open(..) with the parameters specified,

  9533  * verify the return value is 0. Call the RMMFController::Close() on the Custom Controller.

  9534  * Verify error is 0. There will be a memory allocation error while calling iSubThread.Logon()

  9535  * inside RMMFControllerProxy::Close().

  9537  * Use case: N/A

  9538  * @test Req. INC108007

  9539  */

  9540 	{

  9541 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  9542 	__MM_HEAP_MARK;

  9544 	TVerdict verdict = EPass;

  9546 	TMMFPrioritySettings settings;

  9547 	TInt error = KErrNone;

  9548 	RMMFController controller;

  9550 	settings.iPriority = 1;

  9551 	settings.iPref = EMdaPriorityPreferenceTime;

  9552 	settings.iState = EMMFStateIdle;

  9554 	INFO_PRINTF1(_L("Attempting to Open Controller"));

  9556 	// Open a Custom Controller

  9557 	error = controller.Open(KTstControllerUid,settings);

  9558 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  9560 	if (error)

  9561 		{

  9562 		verdict = EFail;

  9563 		}

  9565 	INFO_PRINTF1(_L("Setting __DbgSetAllocFail"));

  9566 	User::__DbgSetAllocFail(ETrue, RHeap::EFailNext, 1);

  9567 	INFO_PRINTF1(_L("Closing Controller"));

  9568 	controller.Close();

  9569 	INFO_PRINTF1(_L("Reseting __DbgSetAllocFail"));

  9570 	User::__DbgSetAllocFail(ETrue, RHeap::ENone, 1);

  9572 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  9573 	__MM_HEAP_MARKEND;

  9575 	return verdict;

  9576 	}

  9579 //------------------------------------------------------------------

  9581 CTestStep_MMF_CTLFRM_U_0203::CTestStep_MMF_CTLFRM_U_0203()

  9582 	/** Constructor

  9583 	*/

  9584 	{

  9585 	// store the name of this test case

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

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

  9588 	iTestStepName = _L("MM-MMF-CTLFRM-U-0203");

  9591 	}

  9594 TVerdict CTestStep_MMF_CTLFRM_U_0203::DoTestStepL( void )

  9595 /**

  9596  * Call the RMMFController::Open(..) with the parameters specified,

  9597  * verify the return value is 0. Call the RMMFController::Close() on the Custom Controller.

  9598  * Verify error is 0. There will be a memory allocation error while calling timer.CreateLocal()

  9599  * inside RMMFControllerProxy::Close()

  9601  * Use case: N/A

  9602  * @test Req. INC108007

  9603  */

  9604 	{

  9605 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  9606 	__MM_HEAP_MARK;

  9608 	TVerdict verdict = EPass;

  9610 	TMMFPrioritySettings settings;

  9611 	TInt error = KErrNone;

  9612 	RMMFController controller;

  9614 	settings.iPriority = 1;

  9615 	settings.iPref = EMdaPriorityPreferenceTime;

  9616 	settings.iState = EMMFStateIdle;

  9618 	INFO_PRINTF1(_L("Attempting to Open Controller"));

  9620 	// Open a Custom Controller

  9621 	error = controller.Open(KTstControllerUid,settings);

  9622 	INFO_PRINTF2(_L("Controller Open: %d"), error);

  9624 	if (error)

  9625 		{

  9626 		verdict = EFail;

  9627 		}

  9629 	INFO_PRINTF1(_L("Setting __DbgSetAllocFail"));

  9630 	User::__DbgSetAllocFail(ETrue, RHeap::EDeterministic, 2);

  9631 	INFO_PRINTF1(_L("Closing Controller"));

  9632 	controller.Close();

  9633 	INFO_PRINTF1(_L("Reseting __DbgSetAllocFail"));

  9634 	User::__DbgSetAllocFail(ETrue, RHeap::ENone, 1);

  9636 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  9637 	__MM_HEAP_MARKEND;

  9639 	return verdict;

  9640 	}

  9643 //------------------------------------------------------------------

  9645 #ifdef SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

  9646 TVerdict CTestStep_MMF_CTLFRM_Subtitles::DoTestStepPreambleL()

  9647 	{

  9648 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

  9649 	__MM_HEAP_MARK;

  9651 	TMMFPrioritySettings settings;

  9652 	settings.iPriority = 1;

  9653 	settings.iPref = EMdaPriorityPreferenceTime;

  9654 	settings.iState = EMMFStateIdle;

  9656 	// Open a Custom Controller

  9657 	TInt error = iController.Open(KTstControllerUid, settings);

  9659 	if (KErrNone != error)

  9660 		{

  9661 		ERR_PRINTF2(_L("Controller Open: %d"), error);

  9662 		return EInconclusive; // Cannot run the test

  9663 		}

  9665 	iSubtitleCommands = new(ELeave) RMMFVideoPlaySubtitleSupportCustomCommands(iController);

  9666 	return CTestStep_MMF_CTLFRM::DoTestStepPreambleL();

  9667 	}

  9669 TVerdict CTestStep_MMF_CTLFRM_Subtitles::DoTestStepPostambleL()

  9670 	{

  9671 	iController.Close();

  9672 	delete iSubtitleCommands;

  9673 	iSubtitleCommands = NULL;

  9675 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

  9676 	__MM_HEAP_MARKEND;

  9678 	return EPass;

  9679 	}

  9681 TVerdict CTestStep_MMF_CTLFRM_Subtitles::CheckExpectedFunctionText(const TDesC8& aExpected)

  9682 	{

  9683 	INFO_PRINTF1(_L("Getting Log"));

  9685 	TBuf8<64> memFunctionText;

  9687 	TUid uid = {KMmfTestControllerUid};

  9688 	TMMFMessageDestination handleInfo(uid);

  9689 	TMMFMessageDestinationPckg messageDest(handleInfo);

  9691 	TInt error = iController.CustomCommandSync(messageDest, KLogFunction, KNullDesC8, KNullDesC8, memFunctionText);

  9693 	if (KErrNone != error)

  9694 		{

  9695 		ERR_PRINTF2(_L("Failed to retrieve function text.  Error is %d"), error);

  9696 		return EFail;

  9697 		}

  9699 	TBuf<64> memFunctionText16;

  9700 	memFunctionText16.Copy(memFunctionText);

  9702 	if (memFunctionText != aExpected)

  9703 		{

  9704 		TBuf<64> expected16;

  9705 	 	expected16.Copy(aExpected);

  9706 		ERR_PRINTF3(_L("Function log expected \"%S\" but got \"%S\""), &expected16, &memFunctionText16);

  9707 		return EFail;

  9708 		}

  9709 	else

  9710 		{

  9711 		INFO_PRINTF2(_L("Log:%S"),&memFunctionText16);

  9712 		}

  9714 	return EPass;

  9715 	}

  9717 void CTestStep_MMF_CTLFRM_Subtitles::SetExpectedSubtitlesAvailableL(TInt aAvailable)

  9718 	{

  9719 	TUid uid = {KMmfTestControllerUid};

  9720 	TMMFMessageDestination handleInfo(uid);

  9721 	TMMFMessageDestinationPckg messageDest(handleInfo);

  9722 	TPckgBuf<TInt> availPckg(aAvailable);

  9724 	User::LeaveIfError(iController.CustomCommandSync(messageDest, KTestSetSubtitleAvailable, availPckg, KNullDesC8));

  9725 	}

  9727 CTestStep_MMF_CTRLFRM_U_400::CTestStep_MMF_CTRLFRM_U_400()

  9728 	{

  9729 	// store the name of this test case

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

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

  9732 	iTestStepName = _L("MM-MMF-CTLFRM-U-0400");

  9733 	}

  9735 TVerdict CTestStep_MMF_CTRLFRM_U_400::DoTestStepL()

  9736 	{

  9737 	TBool avail = EFalse;

  9738 	TInt err = iSubtitleCommands->GetSubtitlesAvailable(avail);

  9740 	if (KErrNone != err)

  9741 		{

  9742 		ERR_PRINTF3(_L("SubtitlesAvailable returned error code %d; expected %d"), err, KErrNone);

  9743 		return EFail;

  9744 		}

  9746 	if (!avail)

  9747 		{

  9748 		ERR_PRINTF1(_L("Expected subtitles to be available, but got EFalse"));

  9749 		return EFail;

  9750 		}

  9752 	return CheckExpectedFunctionText(KSubAvailable);

  9753 	}

  9755 CTestStep_MMF_CTRLFRM_U_401::CTestStep_MMF_CTRLFRM_U_401()

  9756 	{

  9757 	// store the name of this test case

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

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

  9760 	iTestStepName = _L("MM-MMF-CTLFRM-U-0401");

  9761 	}

  9763 TVerdict CTestStep_MMF_CTRLFRM_U_401::DoTestStepL()

  9764 	{

  9765 	TInt err = iSubtitleCommands->DisableSubtitles();

  9767 	if (KErrNone != err)

  9768 		{

  9769 		ERR_PRINTF3(_L("DisableSubtitles returned %d; expected %d"), err, KErrNone);

  9770 		return EFail;

  9771 		}

  9773 	return CheckExpectedFunctionText(KDisableSub);

  9774 	}

  9776 CTestStep_MMF_CTRLFRM_U_402::CTestStep_MMF_CTRLFRM_U_402()

  9777 	{

  9778 	// store the name of this test case

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

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

  9781 	iTestStepName = _L("MM-MMF-CTLFRM-U-0402");

  9782 	}

  9784 TVerdict CTestStep_MMF_CTRLFRM_U_402::DoTestStepL()

  9785 	{

  9786 	TInt err = iSubtitleCommands->EnableSubtitles();

  9788 	if (KErrNone != err)

  9789 		{

  9790 		ERR_PRINTF3(_L("EnableSubtitles returned %d; expected %d"), err, KErrNone);

  9791 		return EFail;

  9792 		}

  9794 	return CheckExpectedFunctionText(KEnableSub);

  9795 	}

  9797 CTestStep_MMF_CTRLFRM_U_403::CTestStep_MMF_CTRLFRM_U_403()

  9798 	{

  9799 	// store the name of this test case

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

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

  9802 	iTestStepName = _L("MM-MMF-CTLFRM-U-0403");

  9803 	}

  9805 TVerdict CTestStep_MMF_CTRLFRM_U_403::DoTestStepL()

  9806 	{

  9807 	TMMFSubtitleWindowConfig config;

  9808 	config.iWindowId = KSubtitleWindowId;

  9809 	config.iDisplayMode = KSubtitleDisplayMode;

  9810 	config.iRotation = KSubtitleRotation;

  9811 	config.iWindowClipRect = KSubtitleCrpRect;

  9813 	TInt err = iSubtitleCommands->AddSubtitleConfig(config);

  9815 	if (KErrNone != err)

  9816 		{

  9817 		ERR_PRINTF3(_L("AddSubtitleConfig returned %d; expected %d"), err, KErrNone);

  9818 		return EFail;

  9819 		}

  9821 	return CheckExpectedFunctionText(KAddSubConfig);

  9822 	}

  9824 CTestStep_MMF_CTRLFRM_U_404::CTestStep_MMF_CTRLFRM_U_404()

  9825 	{

  9826 	// store the name of this test case

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

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

  9829 	iTestStepName = _L("MM-MMF-CTLFRM-U-0404");

  9830 	}

  9832 TVerdict CTestStep_MMF_CTRLFRM_U_404::DoTestStepL()

  9833 	{

  9834 	TMMFSubtitleWindowConfig config;

  9835 	config.iWindowId = KSubtitleWindowId;

  9836 	config.iDisplayMode = KSubtitleDisplayMode;

  9837 	config.iRotation = KSubtitleRotation;

  9838 	config.iWindowClipRect = KSubtitleCrpRect;

  9840 	TInt err = iSubtitleCommands->UpdateSubtitleConfig(config);

  9842 	if (KErrNone != err)

  9843 		{

  9844 		ERR_PRINTF3(_L("UpdateSubtitleConfig returned %d; expected %d"), err, KErrNone);

  9845 		return EFail;

  9846 		}

  9848 	return CheckExpectedFunctionText(KUpdateSubConfig);

  9849 	}

  9851 CTestStep_MMF_CTRLFRM_U_405::CTestStep_MMF_CTRLFRM_U_405()

  9852 	{

  9853 	// store the name of this test case

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

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

  9856 	iTestStepName = _L("MM-MMF-CTLFRM-U-0405");

  9857 	}

  9859 TVerdict CTestStep_MMF_CTRLFRM_U_405::DoTestStepL()

  9860 	{

  9861 	TInt err = iSubtitleCommands->RemoveSubtitleConfig(KSubtitleWindowId);

  9863 	if (KErrNone != err)

  9864 		{

  9865 		ERR_PRINTF3(_L("RemoveSubtitleConfig returned %d; expected %d"), err, KErrNone);

  9866 		return EFail;

  9867 		}

  9869 	return CheckExpectedFunctionText(KRemoveSubConfig);

  9870 	}

  9872 CTestStep_MMF_CTRLFRM_U_406::CTestStep_MMF_CTRLFRM_U_406()

  9873 	{

  9874 	// store the name of this test case

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

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

  9877 	iTestStepName = _L("MM-MMF-CTLFRM-U-0406");

  9878 	}

  9880 TVerdict CTestStep_MMF_CTRLFRM_U_406::DoTestStepL()

  9881 	{

  9882 	TWsGraphicId wsId(TWsGraphicId::EUninitialized);

  9883 	TRect rect;

  9884 	TInt err = iSubtitleCommands->GetCrpParameters(KSubtitleWindowId, wsId, rect);

  9886 	if (KErrNone != err)

  9887 		{

  9888 		ERR_PRINTF3(_L("GetCrpParameters returned %d; expected %d"), err, KErrNone);

  9889 		return EFail;

  9890 		}

  9892 	TWsGraphicId wsIdExpected(KSubtitleWsGraphicId);

  9893 	if (wsIdExpected.Compare(wsId) != 0 || KSubtitleCrpRect != rect)

  9894 		{

  9895 		ERR_PRINTF1(_L("Unexpected parameters retrieved from GetCrpParameters"));

  9896 		return EFail;

  9897 		}

  9899 	return CheckExpectedFunctionText(KGetCrpParams);

  9900 	}

  9902 CTestStep_MMF_CTRLFRM_U_407::CTestStep_MMF_CTRLFRM_U_407()

  9903 	{

  9904 	// store the name of this test case

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

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

  9907 	iTestStepName = _L("MM-MMF-CTLFRM-U-0407");

  9908 	}

  9910 TVerdict CTestStep_MMF_CTRLFRM_U_407::DoTestStepL()

  9911 	{

  9912 	RArray<TLanguage> languages;

  9913 	CleanupClosePushL(languages);

  9914 	TRAPD(err, iSubtitleCommands->GetSupportedSubtitleLanguagesL(languages));

  9916 	if (KErrNone != err)

  9917 		{

  9918 		ERR_PRINTF3(_L("GetSupportedSubtitleLanguagesL left with code %d; expected %d"), err, KErrNone);

  9919 		CleanupStack::PopAndDestroy(&languages);

  9920 		return EFail;

  9921 		}

  9923 	if (languages.Count() != 3)

  9924 		{

  9925 		ERR_PRINTF2(_L("Expected 3 languages, but got %d"), languages.Count());

  9926 		CleanupStack::PopAndDestroy(&languages);

  9927 		return EFail;

  9928 		}

  9930 	if (KSubtitleLanguage0 != languages[0] ||

  9931 			KSubtitleLanguage1 != languages[1] ||

  9932 			KSubtitleLanguage2 != languages[2])

  9933 		{

  9934 		ERR_PRINTF1(_L("Unexpected language returned"));

  9935 		CleanupStack::PopAndDestroy(&languages);

  9936 		return EFail;

  9937 		}

  9939 	CleanupStack::PopAndDestroy(&languages);

  9940 	return CheckExpectedFunctionText(KGetSubLangSup);

  9941 	}

  9943 CTestStep_MMF_CTRLFRM_U_408::CTestStep_MMF_CTRLFRM_U_408()

  9944 	{

  9945 	// store the name of this test case

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

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

  9948 	iTestStepName = _L("MM-MMF-CTLFRM-U-0408");

  9949 	}

  9951 TVerdict CTestStep_MMF_CTRLFRM_U_408::DoTestStepL()

  9952 	{

  9953 	TLanguage language = ELangTest;

  9954 	TInt err = iSubtitleCommands->GetSubtitleLanguage(language);

  9956 	if (KErrNone != err)

  9957 		{

  9958 		ERR_PRINTF3(_L("GetSubtitleLanguage returned %d; expected %d"), err, KErrNone);

  9959 		return EFail;

  9960 		}

  9962 	if (KSubtitleLanguage0 != language)

  9963 		{

  9964 		ERR_PRINTF3(_L("Language is %d but expected %d"), language, KSubtitleLanguage0);

  9965 		return EFail;

  9966 		}

  9968 	return CheckExpectedFunctionText(KGetSubLang);

  9969 	}

  9971 CTestStep_MMF_CTRLFRM_U_409::CTestStep_MMF_CTRLFRM_U_409()

  9972 	{

  9973 	// store the name of this test case

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

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

  9976 	iTestStepName = _L("MM-MMF-CTLFRM-U-0409");

  9977 	}

  9979 TVerdict CTestStep_MMF_CTRLFRM_U_409::DoTestStepL()

  9980 	{

  9981 	TInt err = iSubtitleCommands->SetSubtitleLanguage(KSubtitleLanguage0);

  9983 	if (KErrNone != err)

  9984 		{

  9985 		ERR_PRINTF3(_L("SetSubtitleLanguage returned %d; expected %d"), err, KErrNone);

  9986 		return EFail;

  9987 		}

  9989 	return CheckExpectedFunctionText(KSetSubLang);

  9990 	}

  9992 CTestStep_MMF_CTRLFRM_U_410::CTestStep_MMF_CTRLFRM_U_410()

  9993 	{

  9994 	// store the name of this test case

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

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

  9997 	iTestStepName = _L("MM-MMF-CTLFRM-U-0410");

  9998 	}

 10000 TVerdict CTestStep_MMF_CTRLFRM_U_410::DoTestStepL()

 10001 	{

 10002 	// Expect subtitle functions to fail with KErrNotSupported.

 10003 	SetExpectedSubtitlesAvailableL(KErrNotSupported);

 10005 	TBool avail = ETrue;

 10007 	TInt err = iSubtitleCommands->GetSubtitlesAvailable(avail);

 10009 	if (KErrNone != err)

 10010 		{

 10011 		ERR_PRINTF2(_L("GetSubtitlesAvailable returned error %d; expected KErrNone"), err);

 10012 		return EFail;

 10013 		}

 10015 	if (avail)

 10016 		{

 10017 		ERR_PRINTF1(_L("GetSubtitlesAvailable reported subtitles as available."));

 10018 		return EFail;

 10019 		}

 10021 	err = iSubtitleCommands->EnableSubtitles();

 10022 	if (KErrNotSupported != err)

 10023 		{

 10024 		ERR_PRINTF2(_L("EnableSubtitles returned error %d; expected KErrNotSupported"), err);

 10025 		return EFail;

 10026 		}

 10028 	err = iSubtitleCommands->DisableSubtitles();

 10029 	if (KErrNotSupported != err)

 10030 		{

 10031 		ERR_PRINTF2(_L("DisableSubtitles returned error %d; expected KErrNotSupported"), err);

 10032 		return EFail;

 10033 		}

 10035 	TMMFSubtitleWindowConfig config;

 10036 	err = iSubtitleCommands->AddSubtitleConfig(config);

 10037 	if (KErrNotSupported != err)

 10038 		{

 10039 		ERR_PRINTF2(_L("AddSubtitleConfig returned error %d; expected KErrNotSupported"), err);

 10040 		return EFail;

 10041 		}

 10043 	err = iSubtitleCommands->UpdateSubtitleConfig(config);

 10044 	if (KErrNotSupported != err)

 10045 		{

 10046 		ERR_PRINTF2(_L("UpdateSubtitleConfig returned error %d; expected KErrNotSupported"), err);

 10047 		return EFail;

 10048 		}

 10050 	err = iSubtitleCommands->RemoveSubtitleConfig(0);

 10051 	if (KErrNotSupported != err)

 10052 		{

 10053 		ERR_PRINTF2(_L("RemoveSubtitleConfig returned error %d; expected KErrNotSupported"), err);

 10054 		return EFail;

 10055 		}

 10057 	TWsGraphicId wsId(TWsGraphicId::EUninitialized);

 10058 	TRect rect;

 10059 	err = iSubtitleCommands->GetCrpParameters(0, wsId, rect);

 10060 	if (KErrNotSupported != err)

 10061 		{

 10062 		ERR_PRINTF2(_L("GetCrpParameters returned error %d; expected KErrNotSupported"), err);

 10063 		return EFail;

 10064 		}

 10066 	TLanguage language;

 10067 	err = iSubtitleCommands->GetSubtitleLanguage(language);

 10068 	if (KErrNotSupported != err)

 10069 		{

 10070 		ERR_PRINTF2(_L("GetSubtitleLanguage returned error %d; expected KErrNotSupported"), err);

 10071 		return EFail;

 10072 		}

 10074 	err = iSubtitleCommands->SetSubtitleLanguage(language);

 10075 	if (KErrNotSupported != err)

 10076 		{

 10077 		ERR_PRINTF2(_L("SetSubtitleLanguage returned error %d; expected KErrNotSupported"), err);

 10078 		return EFail;

 10079 		}

 10081 	RArray<TLanguage> languages;

 10082 	TRAP(err, iSubtitleCommands->GetSupportedSubtitleLanguagesL(languages));

 10083 	languages.Close();

 10084 	if (KErrNotSupported != err)

 10085 		{

 10086 		ERR_PRINTF2(_L("GetSupportedSubtitleLanguagesL returned error %d; expected KErrNotSupported"), err);

 10087 		return EFail;

 10088 		}

 10090 	return EPass;

 10091 	}

 10093 #endif //SYMBIAN_MULTIMEDIA_SUBTITLE_SUPPORT

 10095 //------------------------------------------------------------------

 10097 CTestStep_MMF_CTLFRM_U_0300::CTestStep_MMF_CTLFRM_U_0300()

 10098 	/** Constructor

 10099 	*/

 10100 	{

 10101 	// store the name of this test case

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

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

 10104 	iTestStepName = _L("MM-MMF-CTLFRM-U-0300");

 10107 	}

 10109 TVerdict CTestStep_MMF_CTLFRM_U_0300::DoTestStepL( void )

 10110 	{

 10111 	INFO_PRINTF1(_L("Setting UHEAP_MARK"));

 10112 	INFO_PRINTF1(_L("CR1655 - Test to check that stack size has been set to 0x4000"));

 10113 	INFO_PRINTF1(_L("On emulator 1MB should be fine, since stack size cannot be set"));

 10114 	__MM_HEAP_MARK;

 10116 	TVerdict verdict = EPass;

 10118 	TMMFPrioritySettings settings;

 10119 	TInt error = KErrNone;

 10120 	RMMFController controller;

 10122 	settings.iPriority = 1;

 10123 	settings.iPref = EMdaPriorityPreferenceTime;

 10124 	settings.iState = EMMFStateIdle;

 10126 	// Open a Custom Controller

 10127 	error = controller.Open(KTstControllerUid,settings);

 10128 	INFO_PRINTF2(_L("Controller Open: %d"), error);

 10129 	TUint32 expectedStackSize;

 10131 	#ifndef __WINSCW__

 10132 	//on hardware we expect the stack size to be set to what is in the resource file

 10133 	expectedStackSize=0x4000;

 10134 	#else

 10135 	//on emulator stack size is 1MB due to it being on a single process / windows thread

 10136 	expectedStackSize=0x100000;

 10137 	#endif

 10139 	TUint32 stksz=0;

 10140 	if (!error)

 10141 		{

 10142 		INFO_PRINTF1(_L("Calling CustomCommandSync"));

 10143 		TUid uid = {KMmfTestControllerUid};

 10144 		TMMFMessageDestination handleInfo(uid);

 10145 		TMMFMessageDestinationPckg messageDest(handleInfo);

 10146 		TPckg<TUint32> stacksize(0);

 10148 		error = controller.CustomCommandSync(messageDest, KFuncThreadStackSize, KNullDesC8, KNullDesC8,stacksize);

 10149 		stksz=stacksize();

 10150 		}

 10152 	if(stksz!=expectedStackSize || error)

 10153 		{

 10154 		verdict=EFail;

 10155 		}

 10156 	INFO_PRINTF2(_L("Stack Size is set to %d"),stksz);

 10157 	INFO_PRINTF1(_L("Closing Controller"));

 10158 	controller.Close();

 10160 	INFO_PRINTF1(_L("Setting UHEAP_MARKEND"));

 10161 	__MM_HEAP_MARKEND;

 10163 	return verdict;

 10164 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--