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

     2 // All rights reserved.

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

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

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #ifndef CHAR_A3F_DEVSOUND_TONETEST_H

    17 #define CHAR_A3F_DEVSOUND_TONETEST_H

    18 

    19 // system includes

    20 #include "char_a3f_devsound_testbase.h"

    21 #include "char_a3f_devsound_toneclient.h"

    22 #include "char_a3f_devsound_playrecordclients.h"

    23 

    24 /*

    25  *========================================================================================================

    26  * MM-A3F-DEVSOUND-CHRTZ-TONE-0001

    27  */

    28 class RA3FDevSoundToneSetConfigTest : public RA3FDevSoundTestBase

    29 	{

    30 public:

    31 	static RA3FDevSoundToneSetConfigTest* NewL(const TDesC& aTestName);

    32 

    33 private:

    34 	RA3FDevSoundToneSetConfigTest(const TDesC& aTestName);

    35 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

    36 	void DoKickoffTestL();

    37 

    38 private:

    39 	TInt iSampleRate;

    40 	TInt iChannels;	

    41 	};

    42 

    43 /*

    44  *========================================================================================================

    45  * MM-A3F-DEVSOUND-CHRTZ-TONE-0002

    46  */

    47 class RA3FDevSoundToneSetPrioritySettingsTest : public RA3FDevSoundTestBase

    48 	{

    49 public:

    50 	static RA3FDevSoundToneSetPrioritySettingsTest* NewL(const TDesC& aTestName);

    51 

    52 private:

    53 	RA3FDevSoundToneSetPrioritySettingsTest(const TDesC& aTestName);

    54 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

    55 	void DoKickoffTestL();

    56 

    57 private:

    58 	TInt iPriority;

    59 	};

    60 

    61 /*

    62  *========================================================================================================

    63  * MM-A3F-DEVSOUND-CHRTZ-TONE-0003

    64  */

    65 class RA3FDevSoundToneSetVolumeTest : public RA3FDevSoundTestBase

    66 	{

    67 public:

    68 	static RA3FDevSoundToneSetVolumeTest* NewL(const TDesC& aTestName);

    69 

    70 private:

    71 	RA3FDevSoundToneSetVolumeTest(const TDesC& aTestName);

    72 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

    73 	void DoKickoffTestL();

    74 	

    75 private:

    76 	TInt iVolume;

    77 	};

    78 

    79 /*

    80  *========================================================================================================

    81  * MM-A3F-DEVSOUND-CHRTZ-TONE-0004

    82  */

    83 class RA3FDevSoundToneVolumeRampTest : public RA3FDevSoundTestBase

    84 	{

    85 public:

    86 	static RA3FDevSoundToneVolumeRampTest* NewL(const TDesC& aTestName);

    87 private:

    88 	RA3FDevSoundToneVolumeRampTest(const TDesC& aTestName);

    89 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

    90 	void DoKickoffTestL();

    91 	void ToneFinished(TInt aError);

    92 private:

    93 	TInt iVolumeRamp;

    94 	TInt iDuration; 

    95 	TInt iFrequencyTone1;

    96 	TTime iStartTime;

    97 	TTime iEndTime;

    98 	TTimeIntervalMicroSeconds iPlayToneTime;

    99 	};

   100 

   101 /*

   102  *========================================================================================================

   103  * MM-A3F-DEVSOUND-CHRTZ-TONE-0005

   104  */

   105 class RA3FDevSoundToneSetToneRepeatsTest : public RA3FDevSoundTestBase

   106 	{

   107 public:

   108 	static RA3FDevSoundToneSetToneRepeatsTest* NewL(const TDesC& aTestName);

   109 private:

   110 	RA3FDevSoundToneSetToneRepeatsTest(const TDesC& aTestName);

   111 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   112 	void DoKickoffTestL();

   113 	void ToneFinished(TInt aError);

   114 private:

   115 	TInt iDuration; 

   116 	TInt iFrequencyTone1;

   117 	TInt iRepeatTrailingSilence;

   118 	TInt iRepeatCount;

   119 	TTime iStartTime;

   120 	TTime iEndTime;

   121 	TTimeIntervalMicroSeconds iPlayToneTime;

   122 	};

   123 

   124 /*

   125  *========================================================================================================

   126  * MM-A3F-DEVSOUND-CHRTZ-TONE-0006

   127  */

   128 class RA3FDevSoundToneSetDTMFLengthsTest : public RA3FDevSoundTestBase

   129 	{

   130 public:

   131 	static RA3FDevSoundToneSetDTMFLengthsTest* NewL(const TDesC& aTestName);

   132 private:

   133 	RA3FDevSoundToneSetDTMFLengthsTest(const TDesC& aTestName);

   134 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   135 	void DoKickoffTestL();

   136 	void ToneFinished(TInt aError);

   137 	

   138 private:

   139 	TBool iFirstToneFinishedCall;

   140 	TInt iToneOnLength;

   141 	TInt iToneOffLength;

   142 	TInt iPauseLength;

   143 	TBuf16<KMaxStringLength> iDTMFString;

   144 	TTime iStartTime;

   145 	TTime iEndTime;

   146 	TTimeIntervalMicroSeconds iPlayToneTime;

   147 	TInt iDTMFPauses;

   148 	TInt iDTMFTones;

   149 	};

   150 

   151 /*

   152  *========================================================================================================

   153  * MM-A3F-DEVSOUND-CHRTZ-TONE-0007

   154  */

   155 class RA3FDevSoundToneSetVolumeWhilePlayingTest : public RA3FDevSoundTestBase

   156 	{

   157 public:

   158 	static RA3FDevSoundToneSetVolumeWhilePlayingTest* NewL(const TDesC& aTestName);

   159 private:

   160 	RA3FDevSoundToneSetVolumeWhilePlayingTest(const TDesC& aTestName);

   161 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   162 	void DoKickoffTestL();

   163 	void DoTimerCallback();

   164 	void ToneFinished(TInt aError);

   165 private:

   166 	TInt iDuration; 

   167 	TInt iVolume;

   168 	TInt iFrequencyTone1;

   169 	TTime iStartTime;

   170 	TTime iEndTime;

   171 	TTimeIntervalMicroSeconds iPlayToneTime;

   172 	};

   173 

   174 /*

   175  *========================================================================================================

   176  * MM-A3F-DEVSOUND-CHRTZ-TONE-0008

   177  */

   178 class RA3FDevSoundToneSetPlayBalanceWhilePlayingTest : public RA3FDevSoundTestBase

   179 	{

   180 public:

   181 	static RA3FDevSoundToneSetPlayBalanceWhilePlayingTest* NewL(const TDesC& aTestName);

   182 private:

   183 	RA3FDevSoundToneSetPlayBalanceWhilePlayingTest(const TDesC& aTestName);

   184 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   185 	void DoKickoffTestL();

   186 	void DoTimerCallback();

   187 	void ToneFinished(TInt aError);

   188 	

   189 private:

   190 	TInt iDuration; 

   191 	TInt iVolume;

   192 	TInt iFrequencyTone1;

   193 	TInt  iLSpeakerBalance;

   194 	TInt  iRSpeakerBalance;

   195 	TTime iStartTime;

   196 	TTime iEndTime;

   197 	TTimeIntervalMicroSeconds iPlayToneTime;

   198 	};

   199 

   200 /*

   201  *========================================================================================================

   202  * MM-A3F-DEVSOUND-CHRTZ-TONE-0009

   203  */

   204 class RA3FDevSoundToneSetVolumeWhilePausePlayingTest : public RA3FDevSoundTestBase

   205 	{

   206 public:

   207 	static RA3FDevSoundToneSetVolumeWhilePausePlayingTest* NewL(const TDesC& aTestName);

   208 private:

   209 	RA3FDevSoundToneSetVolumeWhilePausePlayingTest(const TDesC& aTestName);

   210 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   211 	void DoKickoffTestL();

   212 	void DoTimerCallback();

   213 	void ToneFinished(TInt aError);

   214 private:

   215 	TInt  iDuration; 

   216 	TInt  iVolume;

   217 	TInt  iFrequencyTone1;

   218 	TBool iTimeToEnterPauseElapsed;

   219 	};

   220 

   221 /*

   222  *========================================================================================================

   223  * MM-A3F-DEVSOUND-CHRTZ-TONE-0010

   224  */

   225 class RA3FDevSoundToneSetVolumeThenInitializeToPlayAudioTest : public RA3FDevSoundTestBase

   226 	{

   227 public:

   228 	static RA3FDevSoundToneSetVolumeThenInitializeToPlayAudioTest* NewL(const TDesC& aTestName);

   229 private:

   230 	RA3FDevSoundToneSetVolumeThenInitializeToPlayAudioTest(const TDesC& aTestName);

   231 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   232 	void DoKickoffTestL();

   233 	

   234 private:

   235 	TInt iVolume;

   236 	TBool iReinitialized;

   237 	};

   238 

   239 /*

   240  *========================================================================================================

   241  * MM-A3F-DEVSOUND-CHRTZ-TONE-0011

   242  */

   243 class RA3FDevSoundToneSetVolumeRampWhilePlayingTest : public RA3FDevSoundTestBase

   244 	{

   245 public:

   246 	static RA3FDevSoundToneSetVolumeRampWhilePlayingTest* NewL(const TDesC& aTestName);

   247 private:

   248 	RA3FDevSoundToneSetVolumeRampWhilePlayingTest(const TDesC& aTestName);

   249 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   250 	void DoKickoffTestL();

   251 	void DoTimerCallback();

   252 	void ToneFinished(TInt aError);

   253 

   254 private:

   255 	TInt iDuration; 

   256 	TInt iVolume;

   257 	TInt iFrequencyTone1;

   258 	TInt iVolumeRamp;

   259 	TBool iTonePlayedTwice;

   260 	TTime iStartTime;

   261 	TTime iEndTime;

   262 	TTimeIntervalMicroSeconds iPlayToneTime;

   263 	TInt iTimesToneFinishedCalled;

   264 	};

   265 

   266 /*

   267  *========================================================================================================

   268  * MM-A3F-DEVSOUND-CHRTZ-TONE-0012

   269  */

   270 class RA3FDevSoundToneSetToneRepetitionsWhilePlayingTest : public RA3FDevSoundTestBase

   271 	{

   272 public:

   273 	static RA3FDevSoundToneSetToneRepetitionsWhilePlayingTest* NewL(const TDesC& aTestName);

   274 private:

   275 	RA3FDevSoundToneSetToneRepetitionsWhilePlayingTest(const TDesC& aTestName);

   276 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   277 	void DoKickoffTestL();

   278 	void DoTimerCallback();

   279 	void ToneFinished(TInt aError);

   280 	

   281 private:

   282 	TInt iDuration; 

   283 	TInt iFrequencyTone1;

   284 	TInt iRepeatTrailingSilence;

   285 	TInt iRepeatCount;

   286 	TTime iStartTime;

   287 	TTime iEndTime;

   288 	TTimeIntervalMicroSeconds iPlayToneTime;

   289 	};

   290 

   291 /*

   292  *========================================================================================================

   293  * MM-A3F-DEVSOUND-CHRTZ-TONE-0013

   294  */

   295 class RA3FDevSoundToneSetDTMFLengthsWhilePlayingTest : public RA3FDevSoundTestBase

   296 	{

   297 public:

   298 	static RA3FDevSoundToneSetDTMFLengthsWhilePlayingTest* NewL(const TDesC& aTestName);

   299 private:

   300 	RA3FDevSoundToneSetDTMFLengthsWhilePlayingTest(const TDesC& aTestName);

   301 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   302 	void DoKickoffTestL();

   303 	void DoTimerCallback();

   304 	void ToneFinished(TInt aError);

   305 

   306 private:

   307 	TBool iFirstToneFinishedCall;

   308 	TInt iToneOnLength;

   309 	TInt iToneOffLength;

   310 	TInt iPauseLength;

   311 	TBuf16<KMaxStringLength> iDTMFString;

   312 	TTime iStartTime;

   313 	TTime iEndTime;

   314 	TTimeIntervalMicroSeconds iPlayToneTime;

   315 	TInt iDTMFPauses;

   316 	TInt iDTMFTones;

   317 	TInt iTotalExpectedPlayToneTime;

   318 	};

   319 

   320 /*

   321  *========================================================================================================

   322  * MM-A3F-DEVSOUND-CHRTZ-TONE-0014

   323  */

   324 class RA3FDevSoundToneSetToneRepetitionsNotPlayingTonesModeTest : public RA3FDevSoundTestBase

   325 	{

   326 public:

   327 	static RA3FDevSoundToneSetToneRepetitionsNotPlayingTonesModeTest* NewL(const TDesC& aTestName);

   328 private:

   329 	RA3FDevSoundToneSetToneRepetitionsNotPlayingTonesModeTest(const TDesC& aTestName);

   330 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   331 	void DoKickoffTestL();

   332 	void ToneFinished(TInt aError);

   333 	

   334 private:

   335 	TInt iDuration; 

   336 	TInt iFrequencyTone1;

   337 	TInt iRepeatTrailingSilence;

   338 	TInt iRepeatCount;	

   339 	TTime iStartTime;

   340 	TTime iEndTime;

   341 	TTimeIntervalMicroSeconds iPlayToneTime;

   342 	TBool iInitializedToPlayTones;

   343 	};

   344 	

   345 /*

   346  *========================================================================================================

   347  * MM-A3F-DEVSOUND-CHRTZ-TONE-0015

   348  */

   349 class RA3FDevSoundToneSetDTMFLengthsNotPlayingTonesModeTest : public RA3FDevSoundTestBase

   350 	{

   351 public:

   352 	static RA3FDevSoundToneSetDTMFLengthsNotPlayingTonesModeTest* NewL(const TDesC& aTestName);

   353 

   354 private:

   355 	RA3FDevSoundToneSetDTMFLengthsNotPlayingTonesModeTest(const TDesC& aTestName);

   356 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   357 	void DoKickoffTestL();

   358 	void ToneFinished(TInt aError);

   359 	

   360 private:

   361 	TBool iInitializedToPlayTones;

   362 	TBuf16<KMaxStringLength> iDTMFString;

   363 	TInt iToneOnLength;

   364 	TInt iToneOffLength;

   365 	TInt iPauseLength;

   366 	TTime iStartTime;

   367 	TTime iEndTime;

   368 	TTimeIntervalMicroSeconds iPlayToneTime;

   369 	TInt iDTMFPauses;

   370 	TInt iDTMFTones;

   371 	};

   372 

   373 /*

   374  *========================================================================================================

   375  * MM-A3F-DEVSOUND-CHRTZ-TONE-0016

   376  */

   377 class RA3FDevSoundToneSetConfigWhilePlayingTest : public RA3FDevSoundTestBase

   378 	{

   379 public:

   380 	static RA3FDevSoundToneSetConfigWhilePlayingTest* NewL(const TDesC& aTestName);

   381 private:

   382 	RA3FDevSoundToneSetConfigWhilePlayingTest(const TDesC& aTestName);

   383 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   384 	void DoKickoffTestL();

   385 	void DoTimerCallback();

   386 	

   387 private:

   388 	TInt iDuration;

   389 	TInt iVolume;

   390 	TInt iFrequencyTone1;

   391 	TInt iSampleRate;

   392 	TInt iChannels;

   393 	};

   394 

   395 /*

   396  *========================================================================================================

   397  * MM-A3F-DEVSOUND-CHRTZ-TONE-0017

   398  */

   399 class RA3FDevSoundToneSetPriorityWhilePlayingTest : public RA3FDevSoundTestBase, public MA3FDevsoundToneClientObserver

   400 	{

   401 public:

   402 	static RA3FDevSoundToneSetPriorityWhilePlayingTest* NewL(const TDesC& aTestName);

   403 private:

   404 	RA3FDevSoundToneSetPriorityWhilePlayingTest(const TDesC& aTestName);

   405 	void ClientInitializeCompleteCallback(TInt aError);

   406 	void ClientToneFinishedCallback(TInt aError);

   407 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   408 	void DoKickoffTestL();

   409 	void DoTimerCallback();

   410 	void ToneFinished(TInt aError);

   411 private:

   412 	

   413 	TInt iDuration;

   414 	TInt iFrequencyTone1;

   415 	};

   416 

   417 /*

   418  *========================================================================================================

   419  * MM-A3F-DEVSOUND-CHRTZ-TONE-0018

   420  */

   421 class RA3FDevSoundToneSetConfigTestToInvalidSampleRateValue : public RA3FDevSoundTestBase

   422 	{

   423 public:

   424 	static RA3FDevSoundToneSetConfigTestToInvalidSampleRateValue* NewL(const TDesC& aTestName);

   425 

   426 private:

   427 	RA3FDevSoundToneSetConfigTestToInvalidSampleRateValue(const TDesC& aTestName);

   428 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   429 	void DoKickoffTestL();

   430 

   431 private:

   432 	TInt iSampleRate;

   433 	TInt iChannels;	

   434 	};

   435 

   436 /*

   437  *========================================================================================================

   438  * MM-A3F-DEVSOUND-CHRTZ-TONE-0019

   439  */

   440 class RA3FDevSoundToneSetConfigTestToInvalidChannelValueTest : public RA3FDevSoundTestBase

   441 	{

   442 public:

   443 	static RA3FDevSoundToneSetConfigTestToInvalidChannelValueTest* NewL(const TDesC& aTestName);

   444 

   445 private:

   446 	RA3FDevSoundToneSetConfigTestToInvalidChannelValueTest(const TDesC& aTestName);

   447 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   448 	void DoKickoffTestL();

   449 

   450 private:

   451 	TInt iSampleRate;

   452 	TInt iChannels;	

   453 	};

   454 

   455 /*

   456  *========================================================================================================

   457  * MM-A3F-DEVSOUND-CHRTZ-TONE-0020

   458  */

   459 class RA3FDevSoundToneSetDTMFLengthsToNegativeTest : public RA3FDevSoundTestBase

   460 	{

   461 public:

   462 	static RA3FDevSoundToneSetDTMFLengthsToNegativeTest* NewL(const TDesC& aTestName);

   463 private:

   464 	RA3FDevSoundToneSetDTMFLengthsToNegativeTest(const TDesC& aTestName);

   465 	void ToneFinished(TInt aError);

   466 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   467 	void DoKickoffTestL();

   468 	

   469 private:

   470 	TInt iToneOnLength;

   471 	TInt iToneOffLength;

   472 	TInt iPauseLength;

   473 	TBuf16<KMaxStringLength> iDTMFString;

   474 	TTime iStartTime;

   475 	TTime iEndTime;

   476 	TTimeIntervalMicroSeconds iPlayToneTime;

   477 	};

   478 	

   479 /*

   480  *========================================================================================================

   481  * MM-A3F-DEVSOUND-CHRTZ-TONE-0021

   482  */

   483 class RA3FDevSoundToneSetDTMFToneOnLengthToMinusOneTest : public RA3FDevSoundTestBase

   484 	{

   485 public:

   486 	static RA3FDevSoundToneSetDTMFToneOnLengthToMinusOneTest* NewL(const TDesC& aTestName);

   487 private:

   488 	RA3FDevSoundToneSetDTMFToneOnLengthToMinusOneTest(const TDesC& aTestName);

   489 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   490 	void DoKickoffTestL();

   491 	void DoTimerCallback();

   492 	void ToneFinished(TInt aError);

   493 	

   494 private:

   495 	TBool iFirstToneFinishedCall;

   496 	TInt iToneOnLength;

   497 	TInt iToneOffLength;

   498 	TInt iPauseLength;

   499 	TBuf16<KMaxStringLength> iDTMFString;

   500 	TTime iStartTime;

   501 	TTime iEndTime;

   502 	TTimeIntervalMicroSeconds iPlayToneTime;

   503 	};

   504 

   505 /*

   506  *========================================================================================================

   507  * MM-A3F-DEVSOUND-CHRTZ-TONE-0022

   508  */

   509 class RA3FDevSoundToneSetToneRepetitionsRepeatTrailingSilenceToNegativeTest : public RA3FDevSoundTestBase

   510 	{

   511 public:

   512 	static RA3FDevSoundToneSetToneRepetitionsRepeatTrailingSilenceToNegativeTest* NewL(const TDesC& aTestName);

   513 private:

   514 	RA3FDevSoundToneSetToneRepetitionsRepeatTrailingSilenceToNegativeTest(const TDesC& aTestName);

   515 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   516 	void DoKickoffTestL();

   517 	void ToneFinished(TInt aError);

   518 	

   519 private:

   520 	TInt iDuration; 

   521 	TInt iFrequencyTone1;

   522 	TInt iRepeatTrailingSilence;

   523 	TInt iRepeatCount;	

   524 	TTime iStartTime;

   525 	TTime iEndTime;

   526 	TTimeIntervalMicroSeconds iPlayToneTime;

   527 	TBool iInitializedToPlayTones;

   528 	};

   529 

   530 /*

   531  *========================================================================================================

   532  * MM-A3F-DEVSOUND-CHRTZ-TONE-0023

   533  */

   534 class RA3FDevSoundToneSetToneRepetitionsRepeatCountToKMdaRepeatForeverTest : public RA3FDevSoundTestBase

   535 	{

   536 public:

   537 	static RA3FDevSoundToneSetToneRepetitionsRepeatCountToKMdaRepeatForeverTest* NewL(const TDesC& aTestName);

   538 private:

   539 	RA3FDevSoundToneSetToneRepetitionsRepeatCountToKMdaRepeatForeverTest(const TDesC& aTestName);

   540 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   541 	void DoKickoffTestL();

   542 	void ToneFinished(TInt aError);

   543 	void DoTimerCallback();

   544 	

   545 private:

   546 	TInt iDuration; 

   547 	TInt iFrequencyTone1;

   548 	TInt iRepeatTrailingSilence;

   549 	TInt iRepeatCount;	

   550 	TTime iStartTime;

   551 	TTime iEndTime;

   552 	TTimeIntervalMicroSeconds iPlayToneTime;

   553 	TBool iInitializedToPlayTones;

   554 	};

   555 

   556 /*

   557  *========================================================================================================

   558  * MM-A3F-DEVSOUND-CHRTZ-TONE-0024

   559  */

   560 class RA3FDevSoundToneCapsTest : public RA3FDevSoundTestBase

   561 	{

   562 public:

   563 	static RA3FDevSoundToneCapsTest* NewL(const TDesC& aTestName);

   564 private:

   565 	RA3FDevSoundToneCapsTest(const TDesC& aTestName);

   566 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   567 	void DoKickoffTestL();

   568 

   569 private:

   570 	TInt iExCapRate;

   571 	TInt iExCapChannels;

   572 	};

   573 

   574 /*

   575  *========================================================================================================

   576  * MM-A3F-DEVSOUND-CHRTZ-TONE-0025

   577  */

   578 class RA3FDevSoundToneConfigDefaultTest : public RA3FDevSoundTestBase

   579 	{

   580 public:

   581 	static RA3FDevSoundToneConfigDefaultTest* NewL(const TDesC& aTestName);

   582 private:

   583 	RA3FDevSoundToneConfigDefaultTest(const TDesC& aTestName);

   584 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   585 	void DoKickoffTestL();

   586 	

   587 private:

   588 	TMMFSampleRate iExSampleRate;

   589 	TInt iExCapRate;

   590 	TInt iExCapChannels;

   591 	};

   592 	

   593 /*

   594  *========================================================================================================

   595  * MM-A3F-DEVSOUND-CHRTZ-TONE-0026

   596  */

   597 class RA3FDevSoundToneMaxVolumeTest : public RA3FDevSoundTestBase

   598 	{

   599 public:

   600 	static RA3FDevSoundToneMaxVolumeTest* NewL(const TDesC& aTestName);

   601 private:

   602 	RA3FDevSoundToneMaxVolumeTest(const TDesC& aTestName);

   603 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   604 	void DoKickoffTestL();

   605 

   606 private:

   607 	TInt iExVolume;

   608 	};

   609 

   610 /*

   611  *========================================================================================================

   612  * MM-A3F-DEVSOUND-CHRTZ-TONE-0027

   613  */

   614 class RA3FDevSoundToneVolumeTest : public RA3FDevSoundTestBase

   615 	{

   616 public:

   617 	static RA3FDevSoundToneVolumeTest* NewL(const TDesC& aTestName);

   618 private:

   619 	RA3FDevSoundToneVolumeTest(const TDesC& aTestName);

   620 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   621 	void DoKickoffTestL();

   622 	

   623 private:

   624 	TInt iExVolume;

   625 	};

   626 	

   627 /*

   628  *========================================================================================================

   629  * MM-A3F-DEVSOUND-CHRTZ-TONE-0028

   630  */

   631 class RA3FDevSoundToneQueryCapsWhilePlayingTest : public RA3FDevSoundTestBase

   632 	{

   633 public:

   634 	static RA3FDevSoundToneQueryCapsWhilePlayingTest* NewL(const TDesC& aTestName);

   635 private:

   636 	RA3FDevSoundToneQueryCapsWhilePlayingTest(const TDesC& aTestName);

   637 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   638 	void DoKickoffTestL();

   639 	void DoTimerCallback();

   640 	

   641 private:

   642 	TInt iDuration;

   643 	TInt iFrequencyTone1;

   644 	TInt iExCapRate;

   645 	TInt iExCapChannels;

   646 	};

   647 	

   648 /*

   649  *========================================================================================================

   650  * MM-A3F-DEVSOUND-CHRTZ-TONE-0029

   651  */

   652 class RA3FDevSoundToneConfigWhilePlayingTest : public RA3FDevSoundTestBase

   653 	{

   654 public:

   655 	static RA3FDevSoundToneConfigWhilePlayingTest* NewL(const TDesC& aTestName);

   656 private:

   657 	RA3FDevSoundToneConfigWhilePlayingTest(const TDesC& aTestName);

   658 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   659 	void DoKickoffTestL();

   660 	void DoTimerCallback();

   661 	void ToneFinished(TInt aError);

   662 	

   663 private:

   664 	TInt iDuration;

   665 	TInt iFrequencyTone1;

   666 	TInt iExCapRate;

   667 	TInt iExCapChannels;

   668 	TMMFSampleRate iExSampleRate;

   669 	TTime iStartTime;

   670 	TTime iEndTime;

   671 	TTimeIntervalMicroSeconds iPlayToneTime;

   672 	};

   673 

   674 /*

   675  *========================================================================================================

   676  * MM-A3F-DEVSOUND-CHRTZ-TONE-0030

   677  */

   678 class RA3FDevSoundToneMaxVolumeWhilePlayingTest : public RA3FDevSoundTestBase

   679 	{

   680 public:

   681 	static RA3FDevSoundToneMaxVolumeWhilePlayingTest* NewL(const TDesC& aTestName);

   682 private:

   683 	RA3FDevSoundToneMaxVolumeWhilePlayingTest(const TDesC& aTestName);

   684 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   685 	void DoKickoffTestL();

   686 	void DoTimerCallback();

   687 	void ToneFinished(TInt aError);

   688 private:

   689 	TInt iDuration;

   690 	TInt iFrequencyTone1;

   691 	TInt iExVolume;

   692 	TTime iStartTime;

   693 	TTime iEndTime;

   694 	TTimeIntervalMicroSeconds iPlayToneTime;

   695 	};

   696 

   697 /*

   698  *========================================================================================================

   699  * MM-A3F-DEVSOUND-CHRTZ-TONE-0031

   700  */

   701 class RA3FDevSoundToneVolumeWhilePlayingTest : public RA3FDevSoundTestBase

   702 	{

   703 public:

   704 	static RA3FDevSoundToneVolumeWhilePlayingTest* NewL(const TDesC& aTestName);

   705 private:

   706 	RA3FDevSoundToneVolumeWhilePlayingTest(const TDesC& aTestName);

   707 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   708 	void DoKickoffTestL();

   709 	void DoTimerCallback();

   710 	void ToneFinished(TInt aError);

   711 

   712 private:

   713 	TInt iDuration;

   714 	TInt iFrequencyTone1;

   715 	TInt iExVolume;

   716 	TTime iStartTime;

   717 	TTime iEndTime;

   718 	TTimeIntervalMicroSeconds iPlayToneTime;

   719 	};

   720 

   721 /*

   722  *========================================================================================================

   723  * MM-A3F-DEVSOUND-CHRTZ-TONE-0032

   724  */

   725 class RA3FDevSoundToneQueryCapsWhilePausePlayingTest : public RA3FDevSoundTestBase

   726 	{

   727 public:

   728 	static RA3FDevSoundToneQueryCapsWhilePausePlayingTest* NewL(const TDesC& aTestName);

   729 private:

   730 	RA3FDevSoundToneQueryCapsWhilePausePlayingTest(const TDesC& aTestName);

   731 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   732 	void DoKickoffTestL();

   733 	void DoTimerCallback();

   734 	void ToneFinished(TInt aError);

   735 	

   736 private:

   737 	TInt iDuration;

   738 	TInt iFrequencyTone1;

   739 	TInt iExCapRate;

   740 	TInt iExCapChannels;

   741 	TBool iTimeToEnterPauseElapsed;

   742 	};

   743 

   744 /*

   745  *========================================================================================================

   746  * MM-A3F-DEVSOUND-CHRTZ-TONE-0033

   747  */

   748 class RA3FDevSoundToneConfigWhilePausePlayingTest : public RA3FDevSoundTestBase

   749 	{

   750 public:

   751 	static RA3FDevSoundToneConfigWhilePausePlayingTest* NewL(const TDesC& aTestName);

   752 private:

   753 	RA3FDevSoundToneConfigWhilePausePlayingTest(const TDesC& aTestName);

   754 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   755 	void DoKickoffTestL();

   756 	void DoTimerCallback();

   757 	void ToneFinished(TInt aError);

   758 	

   759 private:

   760 	TInt iDuration;

   761 	TInt iFrequencyTone1;

   762 	TBool iTimeToEnterPauseElapsed;

   763 	TInt iExCapRate;

   764 	TInt iExCapChannels;

   765 	TMMFSampleRate iExSampleRate;

   766 	};

   767 

   768 /*

   769  *========================================================================================================

   770  * MM-A3F-DEVSOUND-CHRTZ-TONE-0034

   771  */

   772 class RA3FDevSoundToneMaxVolumeWhilePausePlayingTest : public RA3FDevSoundTestBase

   773 	{

   774 public:

   775 	static RA3FDevSoundToneMaxVolumeWhilePausePlayingTest* NewL(const TDesC& aTestName);

   776 private:

   777 	RA3FDevSoundToneMaxVolumeWhilePausePlayingTest(const TDesC& aTestName);

   778 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   779 	void DoKickoffTestL();

   780 	void DoTimerCallback();

   781 	void ToneFinished(TInt aError);

   782 	

   783 private:

   784 	TInt iDuration;

   785 	TInt iFrequencyTone1;

   786 	TInt iExVolume;

   787 	TBool iTimeToEnterPauseElapsed;

   788 	};

   789 

   790 /*

   791  *========================================================================================================

   792  * MM-A3F-DEVSOUND-CHRTZ-TONE-0035

   793  */

   794 class RA3FDevSoundToneVolumeWhilePausePlayingTest : public RA3FDevSoundTestBase

   795 	{

   796 public:

   797 	static RA3FDevSoundToneVolumeWhilePausePlayingTest* NewL(const TDesC& aTestName);

   798 private:

   799 	RA3FDevSoundToneVolumeWhilePausePlayingTest(const TDesC& aTestName);

   800 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   801 	void DoKickoffTestL();

   802 	void DoTimerCallback();

   803 	void ToneFinished(TInt aError);

   804 

   805 private:

   806 	TInt iDuration;

   807 	TInt iFrequencyTone1;

   808 	TInt iExVolume;

   809 	TBool iTimeToEnterPauseElapsed;

   810 	};

   811 

   812 /*

   813  *========================================================================================================

   814  * MM-A3F-DEVSOUND-CHRTZ-TONE-0036

   815  */

   816 class RA3FDevSoundTonePlayToneOnceTest : public RA3FDevSoundTestBase

   817 	{

   818 public:

   819 	static RA3FDevSoundTonePlayToneOnceTest* NewL(const TDesC& aTestName);

   820 private:

   821 	RA3FDevSoundTonePlayToneOnceTest(const TDesC& aTestName);

   822 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   823 	void DoKickoffTestL();

   824 	void ToneFinished(TInt aError);

   825 private:

   826 	TInt iDuration;

   827 	TInt iFrequencyTone1;

   828 	TTime iStartTime;

   829 	TTime iEndTime;

   830 	TTimeIntervalMicroSeconds iPlayToneTime;

   831 	};

   832 

   833 /*

   834  *========================================================================================================

   835  * MM-A3F-DEVSOUND-CHRTZ-TONE-0037

   836  */

   837 class RA3FDevSoundTonePlayDualToneTest : public RA3FDevSoundTestBase

   838 	{

   839 public:

   840 	static RA3FDevSoundTonePlayDualToneTest* NewL(const TDesC& aTestName);

   841 private:

   842 	RA3FDevSoundTonePlayDualToneTest(const TDesC& aTestName);

   843 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   844 	void DoKickoffTestL();

   845 	void ToneFinished(TInt aError);

   846 private:

   847 	TInt iDuration;

   848 	TInt iFrequencyTone1;

   849 	TInt iFrequencyTone2;

   850 	TTime iStartTime;

   851 	TTime iEndTime;

   852 	TTimeIntervalMicroSeconds iPlayToneTime;

   853 	};

   854 

   855 /*

   856  *========================================================================================================

   857  * MM-A3F-DEVSOUND-CHRTZ-TONE-0038

   858  */

   859 class RA3FDevSoundTonePlayDTMFToneTest : public RA3FDevSoundTestBase

   860 	{

   861 public:

   862 	static RA3FDevSoundTonePlayDTMFToneTest* NewL(const TDesC& aTestName);

   863 private:

   864 	RA3FDevSoundTonePlayDTMFToneTest(const TDesC& aTestName);

   865 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   866 	void DoKickoffTestL();

   867 	void ToneFinished(TInt aError);

   868 private:

   869 	TBuf16<KMaxStringLength> iDTMFString;

   870 	TBool iToneStopped;

   871 	TTime iStartTime;

   872 	TTime iEndTime;

   873 	TTimeIntervalMicroSeconds iPlayToneTime;

   874 	TInt iDTMFPauses;

   875 	TInt iDTMFTones;

   876 	};

   877 

   878 /*

   879  *========================================================================================================

   880  * MM-A3F-DEVSOUND-CHRTZ-TONE-0039

   881  */

   882 class RA3FDevSoundTonePlayToneSequenceTest : public RA3FDevSoundTestBase

   883 	{

   884 public:

   885 	static RA3FDevSoundTonePlayToneSequenceTest* NewL(const TDesC& aTestName);

   886 private:

   887 	RA3FDevSoundTonePlayToneSequenceTest(const TDesC& aTestName);

   888 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   889 	void DoKickoffTestL();

   890 	};

   891 

   892 /*

   893  *========================================================================================================

   894  * MM-A3F-DEVSOUND-CHRTZ-TONE-0040

   895  */

   896 class RA3FDevSoundToneNewToneRequestWhilePlayingTest : public RA3FDevSoundTestBase

   897 	{

   898 public:

   899 	static RA3FDevSoundToneNewToneRequestWhilePlayingTest* NewL(const TDesC& aTestName);

   900 

   901 private:

   902 	RA3FDevSoundToneNewToneRequestWhilePlayingTest(const TDesC& aTestName);

   903 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   904 	void DoKickoffTestL();

   905 	void DoTimerCallback();

   906 	void ToneFinished(TInt aError);

   907 	

   908 private:

   909 	TInt iDuration;

   910 	TInt iFrequencyTone1;

   911 	TTime iStartTime;

   912 	TTime iEndTime;

   913 	TTimeIntervalMicroSeconds iPlayToneTime;

   914 	};

   915 

   916 /*

   917  *========================================================================================================

   918  * MM-A3F-DEVSOUND-CHRTZ-TONE-0041

   919  */

   920 class RA3FDevSoundTonePreemptionTest : public RA3FDevSoundTestBase, public MA3FDevsoundToneClientObserver

   921 	{

   922 public:

   923 	static RA3FDevSoundTonePreemptionTest* NewL(const TDesC& aTestName);

   924 

   925 private:

   926 	RA3FDevSoundTonePreemptionTest(const TDesC& aTestName);

   927 	void ClientInitializeCompleteCallback(TInt aError);

   928 	void ClientToneFinishedCallback(TInt aError);

   929 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   930 	void DoKickoffTestL();

   931 	void DoTimerCallback();

   932 	void ToneFinished(TInt aError);

   933 	

   934 private:

   935 	TInt iDuration;

   936 	TInt iFrequencyTone1;

   937 	};

   938 

   939 /*

   940  *========================================================================================================

   941  * MM-A3F-DEVSOUND-CHRTZ-TONE-0042

   942  */

   943 class RA3FDevSoundToneRejectionTest : public RA3FDevSoundTestBase, public MA3FDevsoundToneClientObserver

   944 	{

   945 public:

   946 	static RA3FDevSoundToneRejectionTest* NewL(const TDesC& aTestName);

   947 

   948 private:

   949 	RA3FDevSoundToneRejectionTest(const TDesC& aTestName);

   950 	void ClientInitializeCompleteCallback(TInt aError);

   951 	void ClientToneFinishedCallback(TInt aError);

   952 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   953 	void DoKickoffTestL();

   954 	void DoTimerCallback();

   955 	void ToneFinished(TInt aError);

   956 	

   957 private:

   958 	TInt iDuration;

   959 	TInt iFrequencyTone1;

   960 	};

   961 

   962 /*

   963  *========================================================================================================

   964  * MM-A3F-DEVSOUND-CHRTZ-TONE-0043

   965  */

   966 class RA3FDevSoundTonePlayToneOnceAndStopTest : public RA3FDevSoundTestBase

   967 	{

   968 public:

   969 	static RA3FDevSoundTonePlayToneOnceAndStopTest* NewL(const TDesC& aTestName);

   970 private:

   971 	RA3FDevSoundTonePlayToneOnceAndStopTest(const TDesC& aTestName);

   972 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   973 	void DoKickoffTestL();

   974 	void DoTimerCallback();

   975 	void ToneFinished(TInt aError);

   976 	

   977 private:

   978 	TInt iDuration;

   979 	TInt iFrequencyTone1;

   980 	TBool iToneStopped;

   981 	};

   982 

   983 /*

   984  *========================================================================================================

   985  * MM-A3F-DEVSOUND-CHRTZ-TONE-0044

   986  */

   987 class RA3FDevSoundTonePlayDualToneOnceAndStopTest : public RA3FDevSoundTestBase

   988 	{

   989 public:

   990 	static RA3FDevSoundTonePlayDualToneOnceAndStopTest* NewL(const TDesC& aTestName);

   991 private:

   992 	RA3FDevSoundTonePlayDualToneOnceAndStopTest(const TDesC& aTestName);

   993 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

   994 	void DoKickoffTestL();

   995 	void DoTimerCallback();

   996 	void ToneFinished(TInt aError);

   997 	

   998 private:

   999 	TInt iDuration;

  1000 	TInt iFrequencyTone1;

  1001 	TInt iFrequencyTone2;

  1002 	TBool iToneStopped;

  1003 	};

  1004 	

  1005 /*

  1006  *========================================================================================================

  1007  * MM-A3F-DEVSOUND-CHRTZ-TONE-0045

  1008  */

  1009 class RA3FDevSoundTonePlayDTMFStringOnceAndStopTest : public RA3FDevSoundTestBase

  1010 	{

  1011 public:

  1012 	static RA3FDevSoundTonePlayDTMFStringOnceAndStopTest* NewL(const TDesC& aTestName);

  1013 private:

  1014 	RA3FDevSoundTonePlayDTMFStringOnceAndStopTest(const TDesC& aTestName);

  1015 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

  1016 	void DoKickoffTestL();

  1017 	void DoTimerCallback();

  1018 	void ToneFinished(TInt aError);

  1019 	

  1020 private:

  1021 	TBuf16<KMaxStringLength> iDTMFString;

  1022 	TBool iToneStopped;

  1023 	};

  1024 

  1025 /*

  1026  *========================================================================================================

  1027  * MM-A3F-DEVSOUND-CHRTZ-TONE-0046

  1028  */

  1029 class RA3FDevSoundTonePlayToneSequenceOnceAndStopTest : public RA3FDevSoundTestBase

  1030 	{

  1031 public:

  1032 	static RA3FDevSoundTonePlayToneSequenceOnceAndStopTest* NewL(const TDesC& aTestName);

  1033 private:

  1034 	RA3FDevSoundTonePlayToneSequenceOnceAndStopTest(const TDesC& aTestName);

  1035 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

  1036 	void DoKickoffTestL();

  1037 	void DoTimerCallback();

  1038 	void ToneFinished(TInt aError);

  1039 private:

  1040 	TBool iToneStopped;

  1041 	};

  1042 

  1043 /*

  1044  *========================================================================================================

  1045  * MM-A3F-DEVSOUND-CHRTZ-TONE-0047

  1046  */

  1047 class RA3FDevSoundTonePlayToneOncePauseTest : public RA3FDevSoundTestBase

  1048 	{

  1049 public:

  1050 	static RA3FDevSoundTonePlayToneOncePauseTest* NewL(const TDesC& aTestName);

  1051 private:

  1052 	RA3FDevSoundTonePlayToneOncePauseTest(const TDesC& aTestName);

  1053 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

  1054 	void DoKickoffTestL();

  1055 	void DoTimerCallback();

  1056 	void ToneFinished(TInt aError);

  1057 	

  1058 private:

  1059 	TInt iDuration;

  1060 	TInt iFrequencyTone1;

  1061 	TBool iPaused;

  1062 	TInt iSamplesPlayedPaused;

  1063 	

  1064 	};

  1065 

  1066 /*

  1067  *========================================================================================================

  1068  * MM-A3F-DEVSOUND-CHRTZ-TONE-0048

  1069  */

  1070 class RA3FDevSoundTonePlayDualToneOncePauseTest : public RA3FDevSoundTestBase

  1071 	{

  1072 public:

  1073 	static RA3FDevSoundTonePlayDualToneOncePauseTest* NewL(const TDesC& aTestName);

  1074 private:

  1075 	RA3FDevSoundTonePlayDualToneOncePauseTest(const TDesC& aTestName);

  1076 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

  1077 	void DoKickoffTestL();

  1078 	void DoTimerCallback();

  1079 	void ToneFinished(TInt aError);

  1080 	

  1081 private:

  1082 	TInt iDuration;

  1083 	TInt iFrequencyTone1;

  1084 	TInt iFrequencyTone2;

  1085 	TBool iPaused;

  1086 	TInt iSamplesPlayedPaused;

  1087 	};

  1088 

  1089 /*

  1090  *========================================================================================================

  1091  * MM-A3F-DEVSOUND-CHRTZ-TONE-0049

  1092  */

  1093 class RA3FDevSoundTonePlayDTMFStringOncePauseTest : public RA3FDevSoundTestBase

  1094 	{

  1095 public:

  1096 	static RA3FDevSoundTonePlayDTMFStringOncePauseTest* NewL(const TDesC& aTestName);

  1097 private:

  1098 	RA3FDevSoundTonePlayDTMFStringOncePauseTest(const TDesC& aTestName);

  1099 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

  1100 	void DoKickoffTestL();

  1101 	void DoTimerCallback();

  1102 	void ToneFinished(TInt aError);

  1103 

  1104 private:

  1105 	TBuf16<KMaxStringLength> iDTMFString;

  1106 	TBool iPaused;

  1107 	TInt iSamplesPlayedPaused;

  1108 	TInt iDTMFPauses;

  1109 	TInt iDTMFTones;

  1110 	};

  1111 

  1112 /*

  1113  *========================================================================================================

  1114  * MM-A3F-DEVSOUND-CHRTZ-TONE-0050

  1115  */

  1116 class RA3FDevSoundTonePlayToneSequenceOncePauseTest : public RA3FDevSoundTestBase

  1117 	{

  1118 public:

  1119 	static RA3FDevSoundTonePlayToneSequenceOncePauseTest* NewL(const TDesC& aTestName);

  1120 private:

  1121 	RA3FDevSoundTonePlayToneSequenceOncePauseTest(const TDesC& aTestName);

  1122 	void Fsm(TMmfDevSoundEvent aDevSoundEvent, TInt aError);

  1123 	void DoKickoffTestL();

  1124 	void DoTimerCallback();

  1125 	void ToneFinished(TInt aError);

  1126 private:

  1127 	TBool iPaused;

  1128 	TInt iSamplesPlayedPaused;

  1129 	};

  1130 

  1131 /*

  1132  *========================================================================================================

  1133  * MM-A3F-DEVSOUND-CHRTZ-TONE-0051

  1134  */