1 /*

     2 * Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  MmfTsTone class member functions

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include "MmfTsTone.h"

    21 #include "TemplateParameters.h"

    22 #include "DTMFParameters.h"

    23 

    24 // EXTERNAL DATA STRUCTURES

    25 // None

    26 

    27 // EXTERNAL FUNCTION PROTOTYPES  

    28 // None

    29 

    30 // CONSTANTS

    31 const TInt CMmfTsTone::KTestCaseVolume=501;

    32 const TInt CMmfTsTone::KTestCaseVolumeRamp=502;

    33 const TInt CMmfTsTone::KTestCaseRepeat=503;

    34 const TInt CMmfTsTone::KTestCaseFixedSequences=504;

    35 const TInt CMmfTsTone::KTestCasePlayFileSequence=505;

    36 const TInt CMmfTsTone::KTestCaseBalance=506;

    37 const TInt CMmfTsTone::KTestCasePriorities=507;

    38 const TInt CMmfTsTone::KTestCaseDTMFString=508;

    39 const TInt CMmfTsTone::KTestCaseCancelPrepare=509;

    40 const TInt CMmfTsTone::KTestCaseDualTone=510;

    41 const TInt CMmfTsTone::KTestCasePlayToneFile=511;

    42 const TInt CMmfTsTone::KTestCasePlayToneRFile=512;  

    43 const TInt CMmfTsTone::KTestCaseCustomInterface=513;  

    44 const TInt CMmfTsTone:: KTestCaseCheckState=514;

    45 const TInt CMmfTsTone:: KTestCaseMaxVolumePlay=515;

    46 const TInt CMmfTsTone::KTestCasePlayCancel=516;

    47 const TInt CMmfTsTone::KTestCasePlayChangeVolume=517;

    48 const TInt CMmfTsTone::KTestCaseInvalidFrequencyCheck=518;

    49 const TInt CMmfTsTone::KTestCaseCorruptFile=519;

    50 

    51 

    52 // MACROS

    53 // None

    54 

    55 // LOCAL CONSTANTS AND MACROS

    56 //typdef TFixedArray<TInt, 2> TTwoIntArray;

    57 

    58 // MODULE DATA STRUCTURES

    59 // None

    60 

    61 // LOCAL FUNCTION PROTOTYPES

    62 // None

    63 

    64 // FORWARD DECLARATIONS

    65 // None

    66 

    67 // ==================== LOCAL FUNCTIONS =======================================

    68 // None

    69 

    70 /*-------------------------------------------------------------------------------

    71 

    72     DESCRIPTION

    73 

    74     This module contains the implementation of MmfTsTone class 

    75 	member functions.

    76 

    77 -------------------------------------------------------------------------------*/

    78 

    79 // ================= MEMBER FUNCTIONS =========================================

    80 

    81 TInt CMmfTsTone::RunTestCaseFunctionL(TInt id, CStifSectionParser * section, TTestResult &aResult) 

    82 	{

    83 	TInt error = KErrNone;

    84 	switch (id)

    85 		{

    86 		case KTestCaseVolume:

    87 		    {

    88 			error = TestCaseVolumeL(section, aResult);

    89 			break;

    90 		    }

    91 		case KTestCaseVolumeRamp:

    92 		    {

    93 		    error = TestCaseVolumeRampL(section, aResult);

    94 			break;

    95 		    }

    96 		case KTestCaseRepeat:

    97 		    {

    98 		    error = TestCaseRepeatL(section, aResult);

    99 			break;

   100 		    }

   101 		case KTestCaseFixedSequences:

   102 		    {

   103 		    error = TestCaseFixedSecuencesL(section, aResult);

   104 		    break;

   105 		    }

   106 		case KTestCasePlayFileSequence:

   107 		    {

   108 		    error = TestCasePlayFileSequenceL(section, aResult);

   109 			break;

   110 		    }

   111 		case KTestCaseBalance:

   112 		    {

   113 		    error = TestCaseBalanceL(section, aResult);

   114 			break;

   115 		    }

   116 		case KTestCasePriorities:

   117 		    {

   118 		    error = TestCasePrioritiesL(section, aResult);

   119 		    break;

   120 		    }

   121 		case KTestCaseDTMFString:

   122 		    {

   123 		    error = TestCaseDTMFStringL(section, aResult);

   124 		    break;

   125 		    }

   126 		case KTestCaseDualTone:

   127 		    {

   128 		    error = TestCaseDualToneL(section, aResult);

   129 			break;

   130 		    }

   131 		case KTestCaseCancelPrepare:

   132 		    {

   133 		    error = TestCaseCancelPrepareL(section, aResult);

   134 		    break;

   135 		    }

   136 		case KTestCasePlayToneFile:

   137 		    {

   138 		    error = TestCasePlayToneFileL(section, aResult);

   139 			break;

   140 		    }

   141 		case KTestCasePlayToneRFile:

   142 		    {

   143 		    error = TestCasePlayToneRFileL(section, aResult);

   144 		    break;

   145 		    }

   146 		case KTestCaseCustomInterface:

   147 		    {

   148 		    error = TestCaseCustomInterfaceL(section, aResult);

   149 		    break;

   150 		    }

   151 		case KTestCaseCheckState:

   152 		    {

   153 		    error=TestCaseCheckStateL(section,aResult);

   154 		    break;

   155 		    }

   156 		case KTestCaseMaxVolumePlay:

   157 		    {

   158 		    error=TestCaseMaxVolumePlayL(section,aResult);

   159 		    break;

   160 		    }

   161 		case KTestCasePlayCancel:

   162 		    {

   163 		    error=TestCaseCancelPlayL(section,aResult);

   164 		    break;

   165 		    }

   166 		case KTestCasePlayChangeVolume:

   167 		    {

   168 		    error=TestCaseVolumeChangeL(section,aResult);

   169 		    break;

   170 		    }

   171 		case KTestCaseInvalidFrequencyCheck:

   172 		    {

   173 		    error = TestCaseDualToneL(section, aResult);

   174 		    break;

   175 		    }

   176 		case KTestCaseCorruptFile:

   177 		    {

   178 		    error=TestCasePlayCorruptFileL(section,aResult);

   179 		    break;

   180 		    }

   181 		default:

   182 		    {

   183 		    aResult.iResultDes.Copy(KConfigInvalid());

   184 		    aResult.iResult = KErrNotExecuted;

   185 		    }

   186 		}

   187 	REComSession::FinalClose();

   188 	return error;

   189 	}

   190 

   191 TInt CMmfTsTone::TestCaseVolumeL(CStifSectionParser *section , TTestResult &aResult) 

   192 	{

   193 	TBool UsingDefault=EFalse;

   194 	TInt Frequency1, Frequency2;

   195 	TTimeIntervalMicroSeconds Duration1, Duration2;

   196 	TObjectCountDown counter;

   197 	aResult.iResult=KErrNone;

   198 	

   199 	Frequency1=Frequency2=KDefaultToneFrequency;

   200 	

   201 	//Obtain the tone's frequency

   202 	Frequency1 = GetIntL(section, KTagToneFrequency, UsingDefault, KDefaultToneFrequency);

   203 	if (UsingDefault) {iOutputPrinter.Printf(_L("Using default tone frequency for player1") );}

   204 	Frequency2 = GetIntL(section, KTagToneFrequency, UsingDefault, KDefaultToneFrequency, ETrue);

   205 	if (UsingDefault) {iOutputPrinter.Printf(_L("Using default tone frequency for player2") );}

   206 

   207 	Duration1 = GetTimeIntervalL(section, KTagToneDuration, UsingDefault, KDefaultToneDuration);

   208 	if (UsingDefault) {iOutputPrinter.Printf(_L("Using default tone duration for player1") );}

   209 	Duration2 = GetTimeIntervalL(section, KTagToneDuration, UsingDefault, KDefaultToneDuration, ETrue);

   210 	if (UsingDefault) {iOutputPrinter.Printf(_L("Using default tone duration for player2") );}

   211 

   212 	iOutputPrinter.Printf(_L("Creating Tone Player1 with frequency (%d) and duration (%d)") , Frequency1, Duration1);

   213 	CTonePlayer *Player1 = CTonePlayer::NewLC(&iOutputPrinter, Frequency1, Duration1);

   214 	Player1->SetId(1);

   215 	Player1->SetSupervisor(&counter);

   216 

   217 	iOutputPrinter.Printf(_L("Creating Tone Player2 with frequency (%d) and duration (%d)") , Frequency2, Duration2);

   218 	CTonePlayer *Player2 = CTonePlayer::NewLC(&iOutputPrinter, Frequency2, Duration2, EFalse);

   219 	Player2->SetId(2);

   220 	Player2->SetSupervisor(&counter);

   221 

   222 	CParameters *PlayParameters = new(ELeave) CParameters(CTonePlayer::KPlayerActionPlay);

   223 	CleanupStack::PushL(PlayParameters);

   224 	Player1->SetExitCompleteTarget(Player2, PlayParameters);

   225 

   226 	TInt MaxVolume1 = Player1->GetMaxVolume();

   227 	TInt MaxVolume2 = Player2->GetMaxVolume();

   228 

   229 	TInt Volume1 = MaxVolume1;

   230 	TInt Volume2 = MaxVolume2 / 2;

   231 

   232 	Player1->SetVolume(Volume1);

   233 	Player2->SetVolume(Volume2);

   234 

   235 	CActiveScheduler::Start();

   236 

   237 	iOutputPrinter.Printf( _L("Player 1: Max (%d) Set (%d) Read (%d)") , MaxVolume1, Volume1, Player1->GetVolume() );

   238 	iOutputPrinter.Printf( _L("Player 2: Max (%d) Set (%d) Read (%d)") , MaxVolume2, Volume2, Player2->GetVolume() );

   239 

   240 	if (Volume1 != Player1->GetVolume() )

   241 		{

   242 		aResult.iResult = KErrExpectedValueDifferent;

   243 		iOutputPrinter.Printf(_L("Volume for Player1 different than volume setup"));

   244 		return KErrExecuted;

   245 		}

   246 	if (Volume2 != Player2->GetVolume() )

   247 		{

   248 		aResult.iResult = KErrExpectedValueDifferent;

   249 		iOutputPrinter.Printf(_L("Volume for Player2 different than volume setup"));

   250 		return KErrExecuted;

   251 		}

   252 

   253 	if (aResult.iResult == KErrExpectedValueDifferent) 

   254 		{

   255 		aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());

   256 		//_LIT(LDifferentValues, "volumes are different");

   257 		iOutputPrinter.Printf( KTestCaseResultFinished() , &KTestCaseResultFailExpectedValueDifferent() );

   258 		}

   259 	else

   260 		{

   261 		aResult.iResult = KErrExecuted;

   262 		aResult.iResultDes.Copy(KTestCaseResultSuccess());

   263 		//_LIT(LSuccess, "success");

   264 		iOutputPrinter.Printf( KTestCaseResultFinished() ,  &KTestCaseResultSuccess() );

   265 		}

   266 

   267 	CleanupStack::PopAndDestroy(PlayParameters);

   268 	CleanupStack::PopAndDestroy(Player2);

   269 	CleanupStack::PopAndDestroy(Player1);

   270 

   271 	return KErrExecuted;

   272 	}

   273 

   274 TInt CMmfTsTone::TestCaseVolumeRampL(CStifSectionParser *section , TTestResult &aResult) 

   275 	{

   276 	TBool UsingDefault=EFalse;

   277 	TInt Frequency=KDefaultToneFrequency;

   278 	TTimeIntervalMicroSeconds Duration, RampDuration;

   279 	TTimeIntervalMicroSeconds32 Delay;

   280 	

   281 	aResult.iResult=KErrNone;

   282 	

   283 	//Obtain the tone's frequency

   284 	Frequency = GetIntL(section, KTagToneFrequency, UsingDefault, KDefaultToneFrequency);

   285 	if (UsingDefault) {iOutputPrinter.Printf(_L("Using default tone frequency for player") );}

   286 

   287 	Duration = GetTimeIntervalL(section, KTagToneDuration, UsingDefault, KDefaultToneDuration);

   288 	if (UsingDefault) {iOutputPrinter.Printf(_L("Using default tone duration for player") );}

   289 

   290 	RampDuration = GetTimeIntervalL(section, KTagRampDuration, UsingDefault, KDefaultRampDuration);

   291 	if (UsingDefault) {iOutputPrinter.Printf(_L("Using default ramp duration for player") );}

   292 

   293 	Delay = GetTimeIntervalL(section, KTagDelay, UsingDefault, KDefaultReportDelay);

   294 	if (UsingDefault) {iOutputPrinter.Printf(_L("Using default report delay for player") );}

   295 

   296 	iOutputPrinter.Printf(_L("Creating Tone Player with frequency (%d) and duration (%d)") , Frequency, Duration);

   297 	CTonePlayer *Player = CTonePlayer::NewLC(&iOutputPrinter, Frequency, Duration);

   298 	iOutputPrinter.Printf(_L("Setting a volume ramp of (%d) microseconds"), RampDuration);

   299 	iOutputPrinter.Printf(_L("Volume sampled every (%d) microseconds"), Delay);

   300 

   301 	Player->SetVolumeRamp(RampDuration);

   302 

   303 	CParameters *ReportParams = new (ELeave) CParameters( CTonePlayer::KPlayerActionReportVolume );

   304 	CleanupStack::PushL(ReportParams);

   305 	//CMediaEvent *mEventReport = CMediaEvent::NewL(TestModuleIf() , *iLogger, Delay, Delay, Player, ReportParams);

   306 	CMediaEvent *mEventReport = CMediaEvent::NewL(&iOutputPrinter, Delay, Delay, Player, ReportParams);

   307 	CleanupStack::Pop(ReportParams);

   308 	CleanupStack::PushL(mEventReport);

   309 

   310 	CActiveScheduler::Start();

   311 

   312 	if (mEventReport->GetCount() <= 0)

   313 	{

   314 		iOutputPrinter.Printf(_L("Not enought events"));

   315 	}

   316 

   317 	if (Player->GetFinalError() )

   318 		{

   319 		aResult.iResult = Player->GetFinalError();

   320 		aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());

   321 		iOutputPrinter.Printf( KTestCaseResultFinished() , &KTestCaseResultFailExpectedValueDifferent() );

   322 		}

   323 	else

   324 		{

   325 		aResult.iResult = KErrExecuted;

   326 		aResult.iResultDes.Copy(KTestCaseResultSuccess());

   327 		iOutputPrinter.Printf( KTestCaseResultFinished() ,  &KTestCaseResultSuccess() );

   328 		}

   329 	CleanupStack::PopAndDestroy(mEventReport);

   330 	CleanupStack::PopAndDestroy(Player);

   331 

   332 	return KErrExecuted;

   333 	}

   334 

   335 

   336 TInt CMmfTsTone::TestCaseRepeatL(CStifSectionParser *section , TTestResult &aResult)

   337 	{

   338 	CTonePlayer *Player;

   339 	TBool UsingDefault=EFalse;

   340 	RArray<TUint> RepeatArray;

   341 	RArray<TTimeIntervalMicroSeconds> RepeatSilenceArray;

   342 	RArray<TUint> FrequencyArray;

   343 	RArray<TTimeIntervalMicroSeconds> DurationArray;

   344 

   345 	RArray<TInt> ErrorArray;

   346 

   347 	//Obtain the error range

   348 	TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   349 	if (UsingDefault) {iOutputPrinter.Printf(_L("Using default error range") );}

   350 

   351 	iOutputPrinter.Printf(_L("Reading list of repetition configuration"));

   352 	TInt RepeatTimes = GetIntL(section, KTagRepeatTimes, UsingDefault, KDefaultRepeats);

   353 	do {	//If the configuration is not found, at least add 1 default test

   354 		RepeatArray.Append(RepeatTimes);

   355 		iOutputPrinter.Printf(_L("Adding (%d) repetitions") , RepeatTimes);

   356 	} while ( RepeatTimes=GetIntL(section, KTagRepeatTimes, UsingDefault, 1, ETrue) , !UsingDefault );

   357 

   358 	iOutputPrinter.Printf(_L("Reading list of repetition silence intervals"));

   359 	TTimeIntervalMicroSeconds RepeatSilence = GetTimeIntervalL(section, KTagSilenceDuration, UsingDefault, KDefaultSilenceDuration);

   360 	do {	//If the configuration is not found, at least add 1 default test

   361 		RepeatSilenceArray.Append(RepeatSilence);

   362 		iOutputPrinter.Printf(_L("Adding silence interval of (%d) microseconds") , RepeatSilence);

   363 	} while ( RepeatSilence=GetTimeIntervalL(section, KTagSilenceDuration, UsingDefault, KDefaultSilenceDuration, ETrue) , !UsingDefault );

   364 

   365 	// Reading Tones

   366 	iOutputPrinter.Printf(_L("Reading list of tone frequencies"));

   367 	TInt Frequency = GetIntL(section, KTagToneFrequency, UsingDefault, KDefaultToneFrequency);

   368 	do {	//If the configuration is not found, at least add 1 default test

   369 		FrequencyArray.Append(Frequency);

   370 		iOutputPrinter.Printf(_L("Adding frequency (%d)") , Frequency);

   371 	} while ( Frequency=GetIntL(section, KTagToneFrequency, UsingDefault, KDefaultToneFrequency, ETrue) , !UsingDefault );

   372 

   373 	iOutputPrinter.Printf(_L("Reading list of tone durations"));

   374 	TTimeIntervalMicroSeconds Duration = GetTimeIntervalL(section, KTagToneDuration, UsingDefault, KDefaultToneDuration);

   375 	do {	//If the configuration is not found, at least add 1 default test

   376 		DurationArray.Append(Duration);

   377 		iOutputPrinter.Printf(_L("Adding tone duration of (%d) microseconds") , Duration);

   378 	} while ( Duration=GetTimeIntervalL(section, KTagToneDuration, UsingDefault, KDefaultToneDuration, ETrue) , !UsingDefault );

   379 

   380 	TInt TestNum;

   381 	RepeatSilence=KDefaultSilenceDuration;

   382 	Frequency = KDefaultToneFrequency;

   383 

   384 	TInt Error=KErrNone;

   385 	TBool HadErrors=EFalse;

   386 	for (TestNum=0; TestNum < RepeatArray.Count() && !Error ; ++TestNum) {

   387 		Error = KErrNone;

   388 		//setup the case for RepeatArray[TestNum] repeats

   389 		RepeatTimes=RepeatArray[TestNum];

   390 		if (TestNum < RepeatSilenceArray.Count() ) { RepeatSilence = RepeatSilenceArray[TestNum]; }

   391 		if (TestNum < FrequencyArray.Count() ) { Frequency = FrequencyArray[TestNum]; }

   392 		if (TestNum < DurationArray.Count() ) { Duration = DurationArray[TestNum];}

   393 		//TestWithRepeats: RepeatTimes & RepeatSilence

   394 		iOutputPrinter.Printf(_L("Creating Tone Player with frequency (%d) and duration (%d)") , Frequency, Duration);

   395 		Player = CTonePlayer::NewLC(&iOutputPrinter, Frequency, Duration);

   396 		iOutputPrinter.Printf(_L("Repeating (%d) times with silence intervals of (%d) microseconds") , RepeatTimes,RepeatSilence );

   397 		Player->SetRepeats(RepeatTimes,RepeatSilence);

   398 		CActiveScheduler::Start();

   399 		//Error=Player->GetFinalError() ;

   400 		

   401 		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

   402 		if (!IsDurationInRange(RepeatTimes, Duration, RepeatSilence, ErrorRange, Player->GetPlayStartTime(), Player->GetPlayStopTime() ) )

   403 			{

   404 			Error = KErrExpectedValueDifferent;

   405 			}

   406 		// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

   407 		//TODO: Calculate the expected duration taking into account the final silence (it should be present, according to SACF)

   408 		if ( !Error) { Error=Player->GetFinalError(); }

   409 		if ( Error ) { HadErrors = ETrue; }

   410 		ErrorArray.Append(Error);

   411 

   412 		CleanupStack::PopAndDestroy(Player);

   413 	}

   414 

   415 	//Do test with the last parameters, and interrupt it.

   416 	if (!Error)

   417 		{

   418 		TTimeIntervalMicroSeconds32 Delay = GetTimeIntervalL(section, KTagDelay, UsingDefault, KDefaultStopDelay);

   419 		//Player = CTonePlayer::NewLC();

   420 		iOutputPrinter.Printf(_L("Creating Tone Player with frequency (%d) and duration (%d)") , Frequency, Duration);

   421 		CTonePlayer *Player = CTonePlayer::NewLC(&iOutputPrinter, Frequency, Duration);

   422 		iOutputPrinter.Printf(_L("Repeating (%d) times with silence intervals of (%d) microseconds") , RepeatTimes,RepeatSilence );

   423 		Player->SetRepeats(RepeatTimes,RepeatSilence);

   424 

   425 		CParameters *StopParams = new (ELeave) CParameters( CTonePlayer::KPlayerActionStop );

   426 		CleanupStack::PushL(StopParams);

   427 		//CMediaEvent *MEventStop = CMediaEvent::NewL(TestModuleIf() , *iLogger, Delay, Delay, Player, StopParams);

   428 		CMediaEvent *MEventStop = CMediaEvent::NewL(&iOutputPrinter, Delay, Delay, Player, StopParams);

   429 		CleanupStack::Pop(StopParams);

   430 		CleanupStack::PushL(MEventStop);

   431 

   432 		CActiveScheduler::Start();

   433 

   434 		//TODO: Calculate the expected duration taking into account the final silence (it should be present, according to SACF)

   435 		TTimeIntervalMicroSeconds ExpectedDuration = TInt64(Delay.Int());

   436 

   437 		TTime StartTime = Player->GetPlayStartTime();

   438 		TTime EndTimeRange1 = StartTime;

   439 		EndTimeRange1+= ExpectedDuration;

   440 		TTime EndTimeRange2 = EndTimeRange1;

   441 		EndTimeRange1-=ErrorRange;

   442 		EndTimeRange2+=ErrorRange;

   443 		

   444 		iOutputPrinter.Printf(_L("Play duration (%d)") , Player->GetPlayDuration() );

   445 		iOutputPrinter.Printf(_L("Expected duration (%d)") , ExpectedDuration);

   446 		TTime StopTime= Player->GetPlayStopTime();

   447 		if (StopTime<EndTimeRange1 

   448 			|| StopTime>EndTimeRange2) {

   449 			Error = KErrExpectedValueDifferent;

   450 		}

   451 		if ( !Error) { Error=Player->GetFinalError(); }

   452 		//if ( Player->GetFinalError() ) { Error = Player->GetFinalError(); }

   453 

   454 		ErrorArray.Append(Error);

   455 

   456 		CleanupStack::PopAndDestroy(MEventStop);

   457 		CleanupStack::PopAndDestroy(Player);

   458 		}

   459 

   460 	RepeatArray.Close();

   461 	RepeatSilenceArray.Close();

   462 	FrequencyArray.Close();

   463 	DurationArray.Close();

   464 	ErrorArray.Close();

   465 

   466 	if (Error == KErrExpectedValueDifferent)

   467 		{

   468 		aResult.iResult = Error;

   469 		aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());

   470 		iOutputPrinter.Printf(KTestCaseResultFinished() , &KTestCaseResultFailExpectedValueDifferent() );

   471 		return KErrExecuted;

   472 		}

   473 	else if (Error)

   474 		{

   475 		aResult.iResult = Error;

   476 		aResult.iResultDes.Copy(KTestCaseResultFail());

   477 		iOutputPrinter.Printf(KTestCaseResultFinished() , &KTestCaseResultFail() );

   478 		return KErrExecuted;

   479 		}

   480 	else

   481 		{

   482 		aResult.iResult = KErrExecuted;

   483 		aResult.iResultDes.Copy(KTestCaseResultSuccess());

   484 		iOutputPrinter.Printf(KTestCaseResultFinished() , &KTestCaseResultSuccess() );

   485 		return KErrExecuted;

   486 		}

   487 	}

   488 

   489 TInt CMmfTsTone::TestCaseFixedSecuencesL(CStifSectionParser * /*section*/ , TTestResult &aResult) 

   490 	{

   491 	TInt Error=KErrNone;

   492 	CTonePlayer *Player = CTonePlayer::NewLC(&iOutputPrinter);

   493 	TInt FixedSequenceCount = Player->GetFixedSequenceCount();

   494 	

   495 	iOutputPrinter.Printf(_L("count of the sequence:%d"),FixedSequenceCount);

   496 	for (TInt x=0; x<FixedSequenceCount && !Error; ++x)

   497 		{

   498 		const TDesC &Name = Player->GetFixedSequenceName(x);

   499 		iOutputPrinter.Printf(_L("Name of sequence (%d) is %S") , x , &Name );

   500 		Player->PrepareFixedSequence(x, ETrue);

   501 		CActiveScheduler::Start();

   502 		Error = Player->GetFinalError();

   503 		}

   504 

   505 	CleanupStack::PopAndDestroy(Player);

   506 

   507 	if (Error)

   508 		{

   509 		aResult.iResult=Error;

   510 		aResult.iResultDes.Copy( KTestCaseResultFail() );

   511 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFail() );

   512 		}

   513 	else

   514 		{

   515 		aResult.iResult=KErrNone;

   516 		aResult.iResultDes.Copy( KTestCaseResultSuccess() );

   517 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultSuccess() );

   518 		}

   519 	return KErrExecuted;

   520 	}

   521 

   522 TInt CMmfTsTone::TestCasePlayFileSequenceL(CStifSectionParser * section , TTestResult &aResult) 

   523 	{

   524 	TPtrC FileNamePtr;

   525 	TPtrC DesFilePtr;

   526 	TBool haveFileName = !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag) ;

   527 	TBool haveDesFileName = !section->GetLine(KTagSoundDes, DesFilePtr, ENoTag) ;

   528 	if ( haveFileName && haveDesFileName )

   529 		{

   530 		TBool UsingDefault;

   531 		TTimeIntervalMicroSeconds RepeatSilence = GetTimeIntervalL(section, KTagSilenceDuration, UsingDefault, KDefaultSilenceDuration);

   532 		TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   533 		TTimeIntervalMicroSeconds ToneSequenceDurationDes = GetTimeIntervalL(section, KTagExpectedDurationDes, UsingDefault, KDefaultToneDuration);

   534 		TTimeIntervalMicroSeconds ToneSequenceDuration = GetTimeIntervalL(section, KTagExpectedDuration, UsingDefault, KDefaultToneDuration);

   535 

   536 		TFileName FileName = DesFilePtr;

   537 		HBufC8 *Des = GetDescriptor8LC(FileName);

   538 		FileName = FileNamePtr;

   539 

   540 		TInt Error=KErrNone;

   541 		iOutputPrinter.Printf(_L("Creating Tone Player") );

   542 		CTonePlayer *Player = CTonePlayer::NewLC(&iOutputPrinter);

   543 

   544 		RArray<TUint> RepeatArray;

   545 		{

   546 		iOutputPrinter.Printf(_L("Reading list of repetition configuration"));

   547 		TInt RepeatTimes = GetIntL(section, KTagRepeatTimes, UsingDefault, KDefaultRepeats);

   548 		do {	//If the configuration is not found, at least add 1 default test

   549 			RepeatArray.Append(RepeatTimes);

   550 			iOutputPrinter.Printf(_L("Adding (%d) repetitions") , RepeatTimes);

   551 		} while ( RepeatTimes=GetIntL(section, KTagRepeatTimes, UsingDefault, 1, ETrue) , !UsingDefault );

   552 		}

   553 		

   554 	//	for (TInt x=0 ; x < RepeatArray.Count() ; ++x)

   555 	//		{

   556 			Player->PrepareFileSequence(FileName);

   557 //			Player->SetRepeats(RepeatArray[x], RepeatSilence);

   558 			CActiveScheduler::Start();

   559 			Error = Player->GetFinalError();

   560 //			if (Error) { break; }

   561 //			if (!IsDurationInRange(RepeatArray[x], ToneSequenceDuration, RepeatSilence, ErrorRange, Player->GetPlayStartTime() , Player->GetPlayStopTime() ))

   562 //				{ Error = KErrExpectedValueDifferent; break; }

   563 			//check durations

   564 

   565 			Player->PrepareDesSequence(*Des);

   566 			//Player->SetRepeats(RepeatArray[x], RepeatSilence);

   567 			CActiveScheduler::Start();

   568 			Error = Player->GetFinalError();

   569 //			if (Error) { break; }

   570 			//check durations

   571 //			if (!IsDurationInRange(RepeatArray[x], ToneSequenceDurationDes, RepeatSilence, ErrorRange, Player->GetPlayStartTime() , Player->GetPlayStopTime() ))

   572 //				{ Error = KErrExpectedValueDifferent; break;}

   573 

   574 	//		}

   575 

   576 		CleanupStack::PopAndDestroy(Player);

   577 		CleanupStack::PopAndDestroy(Des);

   578 		

   579 		if (Error==KErrExpectedValueDifferent) 

   580 			{

   581 			aResult.iResult=Error;

   582 			aResult.iResultDes.Copy( KTestCaseResultFailExpectedValueDifferent() );

   583 			iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFailExpectedValueDifferent() );

   584 			}

   585 		else if (Error)

   586 			{

   587 			aResult.iResult=Error;

   588 			aResult.iResultDes.Copy( KTestCaseResultFail() );

   589 			iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFail() );

   590 			}

   591 		else

   592 			{

   593 			aResult.iResult=KErrNone;

   594 			aResult.iResultDes.Copy( KTestCaseResultSuccess() );

   595 			iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultSuccess() );

   596 			}

   597 		RepeatArray.Close();

   598 		return KErrExecuted;

   599 		}

   600 	else

   601 		{

   602 		//File to play missing

   603 		aResult.iResultDes.Copy(KConfigInvalid());

   604 		aResult.iResult = KErrNotExecuted;

   605 		return KErrConfigInvalid;

   606 		}

   607 	}

   608 

   609 

   610 

   611 

   612 TInt CMmfTsTone::TestCaseBalanceL(CStifSectionParser * section , TTestResult &aResult) 

   613 	{

   614 	TBool UsingDefault;

   615 	TInt Error=KErrNone;

   616 	RArray<TInt> BalanceArray;

   617 

   618 	// Reading Balance list

   619 	{

   620 	iOutputPrinter.Printf(_L("Reading list of balance settings"));

   621 	TInt Balance = GetIntL(section, KTagBalance, UsingDefault, KDefaultToneFrequency);

   622 	do {	//If the configuration is not found, at least add 1 default test

   623 		BalanceArray.Append(Balance);

   624 		iOutputPrinter.Printf(_L("Adding balance (%d)") , Balance);

   625 	} while ( Balance=GetIntL(section, KTagBalance, UsingDefault, KDefaultToneFrequency, ETrue) , !UsingDefault );

   626 	}

   627 

   628 	CTonePlayer *Player = CTonePlayer::NewLC(&iOutputPrinter);

   629 	TInt FixedSequenceCount = Player->GetFixedSequenceCount();

   630 	iOutputPrinter.Printf(_L("Fixed sequence count is (%d)") , FixedSequenceCount );

   631 

   632 	TInt FixedSequenceNumber = GetIntL(section, KTagSequenceNumber, UsingDefault, KDefaultSequenceNumber);

   633 	const TDesC &Name = Player->GetFixedSequenceName(FixedSequenceNumber);

   634 	iOutputPrinter.Printf(_L("Name of sequence (%d) is %S") , FixedSequenceNumber , &Name );

   635 	

   636 	for (TInt x=0 ; x<BalanceArray.Count() && !Error; ++x)

   637 		{

   638 		TInt Balance;

   639 		Player->PrepareFixedSequence(FixedSequenceNumber);

   640 		iOutputPrinter.Printf(_L("Setting balance to (%d)") , BalanceArray[x] );

   641 		Player->SetBalanceL(BalanceArray[x]);

   642 		CActiveScheduler::Start();

   643 		Error = Player->GetFinalError();

   644 		if (!Error) 

   645 			{

   646 			Balance = Player->GetBalanceL();

   647 			iOutputPrinter.Printf(_L("Balance is set to (%d)") , Balance);

   648 			if ( BalanceArray[x] != Balance)

   649 				{

   650 				iOutputPrinter.Printf(_L("Balance set is different from balance read"));

   651 				Error = KErrExpectedValueDifferent;

   652 				}

   653 			}

   654 		}

   655 

   656 	CleanupStack::PopAndDestroy(Player);

   657 

   658 	if (Error==KErrExpectedValueDifferent)

   659 		{

   660 		aResult.iResult=KErrExpectedValueDifferent;

   661 		aResult.iResultDes.Copy( KTestCaseResultFail() );

   662 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFailExpectedValueDifferent() );

   663 		}

   664 	else if (Error)

   665 		{

   666 		aResult.iResult=Error;

   667 		aResult.iResultDes.Copy( KTestCaseResultFail() );

   668 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFail() );

   669 		}

   670 	else

   671 		{

   672 		aResult.iResult=KErrNone;

   673 		aResult.iResultDes.Copy( KTestCaseResultSuccess() );

   674 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultSuccess() );

   675 		}

   676 	BalanceArray.Close();

   677 	return KErrExecuted;

   678 	}

   679 

   680 TInt CMmfTsTone::TestCasePrioritiesL(CStifSectionParser * section , TTestResult &aResult) 

   681 	{

   682 	TBool UsingDefault;

   683 	TInt Error=KErrNone;

   684 	RArray<TInt> PrioritiesArray;

   685 

   686 	//Read the priorities

   687 	//Sort them from high to low

   688 

   689 	TInt FixedSequenceNumber = GetIntL(section, KTagSequenceNumber, UsingDefault, KDefaultSequenceNumber);

   690 	iOutputPrinter.Printf(_L("Fixed sequence number read (%d)") , FixedSequenceNumber);

   691 

   692 	iOutputPrinter.Printf(_L("Reading list of priorities"));

   693 	CStifItemParser *item = section->GetItemLineL(KTagPriority, ENoTag);

   694 	if (item)

   695 		{

   696 		TInt Priority=0;

   697 		TInt x=0;

   698 		CleanupStack::PushL(item);

   699 

   700 		Error = item->GetInt(KNullDesC, Priority);

   701 		while (!Error && x < 3)

   702 		{	

   703 			PrioritiesArray.InsertInOrderAllowRepeats(Priority);

   704 			Error = item->GetNextInt(Priority);

   705 			++x;

   706 		}

   707 		//if (Error) { Error = KErrConfigInvalid; }

   708 		Error = ( (PrioritiesArray.Count() < 3) ? KErrNotFound:KErrNone );

   709 		CleanupStack::PopAndDestroy(item);

   710 		}

   711 	else

   712 		{

   713 		Error = KErrNotFound;

   714 		}

   715 	if (Error) 

   716 		{

   717 		PrioritiesArray.Close();

   718 		aResult.iResult=Error;

   719 		aResult.iResultDes.Copy( KConfigInvalid() );

   720 		iOutputPrinter.Printf(KTestCaseResultFinished, &KConfigInvalid() );

   721 		return KErrNotExecuted;

   722 		}

   723 

   724 	TObjectCountDown counter;

   725 	

   726 	// We have 3 priorities sorted in PrioritiesArray

   727 	CTonePlayer *PlayerHigh = CTonePlayer::NewLC(&iOutputPrinter);

   728 	CTonePlayer *PlayerMed = CTonePlayer::NewLC(&iOutputPrinter);

   729 	CTonePlayer *PlayerLow = CTonePlayer::NewLC(&iOutputPrinter);

   730 

   731 	iOutputPrinter.Printf(_L("Creating PlayerLow with id (1) and priority (%d)") , PrioritiesArray[0] );

   732 	PlayerLow->SetPriority( PrioritiesArray[0] , EMdaPriorityPreferenceNone);

   733 	PlayerLow->SetId(1);

   734 	PlayerLow->SetSupervisor(&counter);

   735 

   736 	iOutputPrinter.Printf(_L("Creating PlayerMed with id (2) and priority (%d)") , PrioritiesArray[1] );

   737 	PlayerMed->SetPriority( PrioritiesArray[1] , EMdaPriorityPreferenceNone);

   738 	PlayerMed->SetId(2);

   739 	PlayerMed->SetSupervisor(&counter);

   740 

   741 	iOutputPrinter.Printf(_L("Creating PlayerLow with id (3) and priority (%d)") , PrioritiesArray[2] );

   742 	PlayerHigh->SetPriority( PrioritiesArray[2] , EMdaPriorityPreferenceNone);

   743 	PlayerHigh->SetId(3);

   744 	PlayerHigh->SetSupervisor(&counter);

   745 

   746 	//Test 1, Medium - Low - High

   747 	iOutputPrinter.Printf(_L("Playing Med(2), Low(1), High(3)"));

   748 	PlayerMed->PrepareFixedSequence(FixedSequenceNumber);

   749 	PlayerLow->PrepareFixedSequence(FixedSequenceNumber);

   750 	PlayerHigh->PrepareFixedSequence(FixedSequenceNumber);

   751 	CActiveScheduler::Start();

   752 

   753 	Error = PlayerHigh->GetFinalError();

   754 

   755 	if (!Error)

   756 		{

   757 		iOutputPrinter.Printf(_L("Playing High(3), Low(1), Med(2)"));

   758 		PlayerLow->SetSupervisor(&counter);

   759 		PlayerMed->SetSupervisor(&counter);

   760 		PlayerHigh->SetSupervisor(&counter);

   761 

   762 		PlayerHigh->PrepareFixedSequence(FixedSequenceNumber);

   763 		PlayerLow->PrepareFixedSequence(FixedSequenceNumber);

   764 		PlayerMed->PrepareFixedSequence(FixedSequenceNumber);

   765 		CActiveScheduler::Start();

   766 

   767 		Error = PlayerHigh->GetFinalError();

   768 		}

   769 	if (!Error)

   770 		{

   771 		iOutputPrinter.Printf(_L("Playing Low(1), High(3), Med(2)"));

   772 		PlayerLow->SetSupervisor(&counter);

   773 		PlayerMed->SetSupervisor(&counter);

   774 		PlayerHigh->SetSupervisor(&counter);

   775 

   776 		PlayerLow->PrepareFixedSequence(FixedSequenceNumber);

   777 		PlayerHigh->PrepareFixedSequence(FixedSequenceNumber);

   778 		PlayerMed->PrepareFixedSequence(FixedSequenceNumber);

   779 		CActiveScheduler::Start();

   780 

   781 		Error = PlayerHigh->GetFinalError();

   782 		}

   783 	

   784 	CleanupStack::PopAndDestroy(PlayerLow);

   785 	CleanupStack::PopAndDestroy(PlayerMed);

   786 	CleanupStack::PopAndDestroy(PlayerHigh);

   787 

   788 	if (Error)

   789 		{

   790 		aResult.iResult=Error;

   791 		aResult.iResultDes.Copy( KTestCaseResultFail() );

   792 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFail() );

   793 		}

   794 	else

   795 		{

   796 		aResult.iResult=KErrNone;

   797 		aResult.iResultDes.Copy( KTestCaseResultSuccess() );

   798 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultSuccess() );

   799 		}

   800 	PrioritiesArray.Close();

   801 	return KErrExecuted;

   802 	}

   803 

   804 TInt CMmfTsTone::TestCaseDTMFStringL(CStifSectionParser * section , TTestResult &aResult) 

   805 	{

   806 	//aResult.Result=KErrLeft;

   807 	TBool UsingDefault;

   808 	TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   809 	TTimeIntervalMicroSeconds32 ToneDuration = GetTimeIntervalL(section, KTagToneDuration, UsingDefault, KDefaultDTMFToneDuration);

   810 	TTimeIntervalMicroSeconds32 ToneOffDuration = GetTimeIntervalL(section, KTagSilenceDuration, UsingDefault, KDefaultDTMFSilenceDuration);

   811 	TTimeIntervalMicroSeconds32 Pause = GetTimeIntervalL(section, KTagDelay, UsingDefault, KDefaultPauseDelay);

   812 	TInt Error = KErrNone;

   813 	HBufC *DTMFString;

   814 

   815 	{

   816 	TPtrC PtrDTMFString;

   817 	if (section->GetLine(KTagDTMFString, PtrDTMFString, ENoTag) )

   818 		{

   819 		DTMFString = KDefaultDTMFString().AllocLC();

   820 		}

   821 	else

   822 		{

   823 		DTMFString = PtrDTMFString.AllocLC();

   824 		}

   825 	}

   826 

   827 	iOutputPrinter.Printf(_L("Creating Tone Player") );

   828 	CTonePlayer *Player = CTonePlayer::NewLC(&iOutputPrinter);

   829 	iOutputPrinter.Printf(_L("Preparing DTMF sequence [%S]") , DTMFString);

   830 	Player->PrepareDTMFSequence(*DTMFString);

   831 	Player->SetDTMFLengths(ToneDuration, ToneOffDuration, Pause);

   832 

   833 	iOutputPrinter.Printf(_L("Starting scheduler"));

   834 	CActiveScheduler::Start();

   835 

   836 	Error = Player->GetFinalError();

   837 

   838 	TTime ExpectedEnd = Player->GetPlayStartTime();

   839 	for (TInt x=0 ; x < DTMFString->Length() ; ++x)

   840 		{

   841 		if ( (*DTMFString)[x] == KPauseCharacter()[0] )

   842 			{

   843 			ExpectedEnd += Pause;

   844 			}

   845 		else

   846 			{

   847 			ExpectedEnd += ToneDuration;

   848 			ExpectedEnd += ToneOffDuration;

   849 			}

   850 		}

   851 

   852 	iOutputPrinter.Printf(_L("Expected duration: (%d)") , ExpectedEnd.MicroSecondsFrom(Player->GetPlayStartTime()) );

   853 	iOutputPrinter.Printf(_L("Real duration: (%d)") , Player->GetPlayDuration() );

   854 

   855 	TTime ExpectedEnd2 = ExpectedEnd;

   856 	ExpectedEnd -= ErrorRange;

   857 	ExpectedEnd2 += ErrorRange;

   858 

   859 	TBool InRange = ExpectedEnd<Player->GetPlayStopTime() && Player->GetPlayStopTime()<ExpectedEnd2 ;

   860 	if (!InRange)

   861 		{

   862 		Error = KErrExpectedValueDifferent;

   863 		}

   864 

   865 	CleanupStack::PopAndDestroy(Player);

   866 	CleanupStack::PopAndDestroy(DTMFString);

   867 	

   868 	if (!InRange)

   869 		{

   870 		aResult.iResult = KErrExpectedValueDifferent;

   871 		aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());

   872 		iOutputPrinter.Printf( KTestCaseResultFinished() , &KTestCaseResultFailExpectedValueDifferent() );

   873 		}

   874 	else if (Error)

   875 		{

   876 		aResult.iResult=Error;

   877 		aResult.iResultDes.Copy( KTestCaseResultFail() );

   878 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFail() );

   879 		}

   880 	else

   881 		{

   882 		aResult.iResult=KErrNone;

   883 		aResult.iResultDes.Copy( KTestCaseResultSuccess() );

   884 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultSuccess() );

   885 		}

   886 	return KErrExecuted;

   887 	

   888 	}

   889 

   890 TInt CMmfTsTone::TestCaseDualToneL(CStifSectionParser * section , TTestResult &aResult) 

   891 	{

   892 	

   893 	TBool UsingDefault;

   894 	TTimeIntervalMicroSeconds ErrorRange = GetTimeIntervalL(section, KTagErrorRange, UsingDefault, KDefaultErrorRange);

   895 	TTimeIntervalMicroSeconds ToneDuration = GetTimeIntervalL(section, KTagToneDuration, UsingDefault, KDefaultToneDuration);

   896 	TInt Frequency1=KDefaultToneFrequency;

   897 	TInt Frequency2=KDefaultToneFrequency;

   898 	

   899 	TInt Error = KErrNone;

   900 	

   901     TInt ValidityCheck=GetIntL(section, KTagValidity, UsingDefault, KDefaultValidity);

   902 	//Obtain the tone's frequency

   903 	Frequency1 = GetIntL(section, KTagToneFrequency, UsingDefault, KDefaultToneFrequency);

   904 	if (UsingDefault)

   905 		{

   906 		iOutputPrinter.Printf(_L("Using default tone frequency for player") );

   907 		}

   908 	else

   909 		{

   910 		iOutputPrinter.Printf(_L("Using frequency 1 for player (%d)") , Frequency1);

   911 		}

   912 	Frequency2 = GetIntL(section, KTagToneFrequency, UsingDefault, KDefaultToneFrequency, ETrue);

   913 	if (UsingDefault)

   914 		{

   915 		iOutputPrinter.Printf(_L("Using default tone frequency for player") );

   916 		}

   917 	else

   918 		{

   919 		iOutputPrinter.Printf(_L("Using frequency 2 for player (%d)") , Frequency2);

   920 		}

   921 

   922 	

   923 

   924 	iOutputPrinter.Printf(_L("Creating Tone Player") );

   925 	CTonePlayer *Player = CTonePlayer::NewLC(&iOutputPrinter);

   926 	

   927 	Player->PrepareDualTone(Frequency1, Frequency2, ToneDuration);

   928 

   929 	iOutputPrinter.Printf(_L("Starting scheduler"));

   930 	CActiveScheduler::Start();

   931 

   932 	Error = Player->GetFinalError();

   933 

   934 	TBool InRange=ETrue;

   935 	if (!IsDurationInRange(0, ToneDuration, TTimeIntervalMicroSeconds(0), ErrorRange, Player->GetPlayStartTime(), Player->GetPlayStopTime() ) )

   936 		{ //validity check=1 for invalid timeduration

   937 		if(ValidityCheck!=1 && Error!=KErrArgument)

   938 		    {

   939 		    Error = KErrExpectedValueDifferent;

   940 		    }

   941 		

   942 		InRange=EFalse;

   943 		}

   944 

   945 

   946 	CleanupStack::PopAndDestroy(Player);

   947 	

   948 	

   949 	if (!InRange)

   950 		{

   951 		if(ValidityCheck==1)

   952 		    {

   953 		    if(Error==KErrArgument)

   954               {

   955                aResult.iResult=KErrNone;

   956                aResult.iResultDes.Copy( KTestCaseResultSuccess() );

   957                iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultSuccess() );

   958               }

   959 		    else

   960 		       {

   961 		        aResult.iResult=Error;

   962 		        aResult.iResultDes.Copy( KTestCaseResultFail() );

   963 		        iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFail() );

   964 		       }

   965 		    }

   966 		else

   967 		    {

   968 		aResult.iResult = KErrExpectedValueDifferent;

   969 		aResult.iResultDes.Copy(KTestCaseResultFailExpectedValueDifferent());

   970 		iOutputPrinter.Printf( KTestCaseResultFinished() , &KTestCaseResultFailExpectedValueDifferent() );

   971 		

   972 		}

   973 	}

   974 	//validity check=2,for invalid frequencies

   975 	else if(ValidityCheck==2)

   976 	    {

   977 	      if(Error==KErrArgument)

   978 	        {

   979                aResult.iResult=KErrNone;

   980                aResult.iResultDes.Copy( KTestCaseResultSuccess() );

   981                iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultSuccess() );

   982             }

   983           else

   984            {

   985                 aResult.iResult=Error;

   986                 aResult.iResultDes.Copy( KTestCaseResultFail() );

   987                 iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFail() );

   988            }

   989 	    }

   990 	

   991 	else if (Error)

   992 		{

   993 		aResult.iResult=Error;

   994 		aResult.iResultDes.Copy( KTestCaseResultFail() );

   995 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultFail() );

   996 		}

   997 	else

   998 		{

   999 		aResult.iResult=KErrNone;

  1000 		aResult.iResultDes.Copy( KTestCaseResultSuccess() );

  1001 		iOutputPrinter.Printf(KTestCaseResultFinished, &KTestCaseResultSuccess() );

  1002 		}

  1003 	return KErrExecuted;

  1004 	

  1005 	}

  1006 

  1007 TInt CMmfTsTone::TestCaseCancelPrepareL(CStifSectionParser *section , TTestResult &aResult)

  1008 	{

  1009 	TBool UsingDefault, NotUsingCancel;

  1010 	TInt PrepareWhat = GetIntL(section, KTagPrepare, UsingDefault, 1);

  1011 	TTimeIntervalMicroSeconds32 TimeOutDuration = GetTimeIntervalL(section, KTagTimeOut, UsingDefault, KDefaultTimeOutDuration);

  1012 	TInt Error = KErrNone;

  1013 	TInt CancelPriority = GetIntL(section, KTagCancelPriority, NotUsingCancel, CActive::EPriorityHigh);

  1014 	HBufC8 *Des=0;

  1015 

  1016 	CTonePlayer *Player=0;

  1017 	CImmediateMediaEvent *PrepareMediaEvent=0;

  1018 	CParameters *PrepareParameters=0;

  1019 

  1020 	switch (PrepareWhat) {

  1021 		case CTonePlayer::EPrepareTone:

  1022 			{

  1023 			//Obtain the tone's frequency

  1024 			TInt Frequency = GetIntL(section, KTagToneFrequency, UsingDefault, KDefaultToneFrequency);

  1025 			if (UsingDefault)

  1026 				{

  1027 				iOutputPrinter.Printf(_L("Using default tone frequency (%d) for player") , Frequency);

  1028 				}

  1029 			else

  1030 				{

  1031 				iOutputPrinter.Printf(_L("Using frequency 1 for player (%d)") , Frequency);

  1032 				}

  1033 			TTimeIntervalMicroSeconds ToneDuration = GetTimeIntervalL(section, KTagToneDuration, UsingDefault, KDefaultToneDuration);

  1034 			iOutputPrinter.Printf(_L("Creating Tone Player") );

  1035 			Player = CTonePlayer::NewLC(&iOutputPrinter);

  1036 			

  1037 			TFixedArray<TInt64, 2> FreqAndDuration;

  1038 			FreqAndDuration[0] = Frequency;

  1039 			FreqAndDuration[1] = ToneDuration.Int64() ;

  1040 			PrepareParameters = CTemplateParameters<TFixedArray<TInt64, 2> >::NewL(CTonePlayer::KPlayerActionPrepareTone, FreqAndDuration);

  1041 			CleanupStack::PushL(PrepareParameters);

  1042 

  1043 			//PrepareMediaEvent = CImmediateMediaEvent::NewLC(TestModuleIf(), *iLogger, Player, PrepareParameters, CancelPriority+1);

  1044 			PrepareMediaEvent = CImmediateMediaEvent::NewLC(&iOutputPrinter, Player, PrepareParameters, CancelPriority+1);

  1045 			PrepareMediaEvent->FireExecute();

  1046 			break;

  1047 			}

  1048 

  1049 		case CTonePlayer::EPrepareFixedSequence:

  1050 			{

  1051 			TInt SequenceNumber = GetIntL(section, KTagSequenceNumber, UsingDefault, 0);

  1052 			Player = CTonePlayer::NewLC(&iOutputPrinter);

  1053 			//Player->PrepareFixedSequence(SequenceNumber);

  1054 

  1055 			PrepareParameters = CTemplateParameters<TInt>::NewL(CTonePlayer::KPlayerActionPrepareFixedSequence, SequenceNumber);

  1056 			CleanupStack::PushL(PrepareParameters);

  1057 

  1058 			PrepareMediaEvent = CImmediateMediaEvent::NewLC(&iOutputPrinter, Player, PrepareParameters, CancelPriority+1);

  1059 			PrepareMediaEvent->FireExecute();

  1060 			break;

  1061 			}

  1062 

  1063 		case CTonePlayer::EPrepareFileSequence:

  1064 			{

  1065 			TPtrC FileNamePtr;

  1066 			TBool haveFileName = !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag);

  1067 			if (haveFileName)

  1068 				{

  1069 				Player = CTonePlayer::NewLC(&iOutputPrinter);

  1070 

  1071 				TFileName a = FileNamePtr;

  1072 				PrepareParameters = CTemplateParameters<TFileName>::NewL(CTonePlayer::KPlayerActionPrepareFileSequence, a);

  1073 				CleanupStack::PushL(PrepareParameters);

  1074 				

  1075 				PrepareMediaEvent = CImmediateMediaEvent::NewLC(&iOutputPrinter, Player, PrepareParameters, CancelPriority+1);

  1076 				PrepareMediaEvent->FireExecute();

  1077 				}

  1078 			else

  1079 				{

  1080 				iOutputPrinter.Printf(_L("File Name is required"));

  1081 				}

  1082 			break;

  1083 			}

  1084 		case CTonePlayer::EPrepareDesSequence:

  1085 			{

  1086 			TPtrC FileNamePtr;

  1087 			TBool haveFileName = !section->GetLine(KTagSoundFile, FileNamePtr, ENoTag);

  1088 			if (haveFileName)

  1089 				{

  1090 				Des = GetDescriptor8LC(FileNamePtr);

  1091 				Player = CTonePlayer::NewLC(&iOutputPrinter);

  1092 

  1093 				PrepareParameters = CTemplateParameters<HBufC8*>::NewL(CTonePlayer::KPlayerActionPrepareDesSequence, Des);

  1094 				CleanupStack::PushL(PrepareParameters);

  1095 				

  1096 				PrepareMediaEvent = CImmediateMediaEvent::NewLC(&iOutputPrinter, Player, PrepareParameters, CancelPriority+1);

  1097 				PrepareMediaEvent->FireExecute();

  1098 				}

  1099 			else

  1100 				{

  1101 				iOutputPrinter.Printf(_L("File Name is required"));

  1102 				}

  1103 			break;

  1104 			}

  1105 		case CTonePlayer::EPrepareDTMF:

  1106 			{

  1107 			TTimeIntervalMicroSeconds32 ToneDuration = GetTimeIntervalL(section, KTagToneDuration, UsingDefault, KDefaultDTMFToneDuration);

  1108 			TTimeIntervalMicroSeconds32 ToneOffDuration = GetTimeIntervalL(section, KTagSilenceDuration, UsingDefault, KDefaultDTMFSilenceDuration);

  1109 			TTimeIntervalMicroSeconds32 Pause = GetTimeIntervalL(section, KTagDelay, UsingDefault, KDefaultPauseDelay, ETrue);

  1110 

  1111 			iOutputPrinter.Printf(_L("Creating Tone Player") );

  1112 			Player = CTonePlayer::NewLC(&iOutputPrinter);

  1113 			{

  1114 			TPtrC PtrDTMFString;

  1115 			if (section->GetLine(KTagDTMFString, PtrDTMFString, ENoTag) )

  1116 				{

  1117 				PrepareParameters = CDTMFParameters::NewLC(CTonePlayer::KPlayerActionPrepareDTMFSequence, ToneDuration, ToneOffDuration, Pause, KDefaultDTMFString);

  1118 				}

  1119 			else

  1120 				{

  1121 				PrepareParameters = CDTMFParameters::NewLC(CTonePlayer::KPlayerActionPrepareDTMFSequence, ToneDuration, ToneOffDuration, Pause, PtrDTMFString);

  1122 				}

  1123 			}

  1124 			iOutputPrinter.Printf(_L("Preparing DTMF sequence [%S]") , static_cast<CDTMFParameters*>(PrepareParameters)->GetDTMFString() );

  1125 			PrepareMediaEvent = CImmediateMediaEvent::NewLC(&iOutputPrinter, Player, PrepareParameters, CancelPriority+1);

  1126 			PrepareMediaEvent->FireExecute();

  1127 			break;

  1128 			}

  1129 		case CTonePlayer::EPrepareDualTone:

  1130 			{

  1131 			//Obtain the tone's frequency

  1132 			TInt Frequency1 = GetIntL(section, KTagToneFrequency, UsingDefault, KDefaultToneFrequency);

  1133 			if (UsingDefault)

  1134 				{