1 /*

     2 * Copyright (c) 2009 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: CaeTestVideoStates.cpp

    15 *

    16 */

    17 

    18 #include "CaeTestVideoStates.h"

    19 #include <f32file.h>

    20 

    21 

    22 //const TReal32 KViewFinderFrameFrequencyMinimum = 13.0;

    23 

    24 

    25 CCaeTestVideoStates::CCaeTestVideoStates ()

    26     {

    27     }

    28 

    29 

    30 CCaeTestVideoStates::~CCaeTestVideoStates ()

    31     {

    32     }

    33 

    34 

    35 void CCaeTestVideoStates::setUpL ()

    36     {

    37 	iStatesClient = CCaeTestStatesClient::NewL( );

    38 

    39     iStatesClient->SetFileNameBase( KFileNameBase );

    40     }

    41 

    42 

    43 void CCaeTestVideoStates::tearDown ()

    44     {

    45     delete iStatesClient;    

    46     iStatesClient = 0;

    47     }

    48 

    49 

    50 //

    51 // Own test functions.

    52 //

    53 // The framework will do for a test function:

    54 //

    55 // setUpL();

    56 // TRAPD(leaveCode, 'myTestFunction()');

    57 // "Report leave error or assertion failure for 'myTestFunction()'".

    58 // tearDown();

    59 //

    60 

    61 

    62 /********************************************************/

    63 /*  VIDEO RECORDING PREPARE AND RECORD QUALITY LEVEL    */

    64 /********************************************************/

    65 

    66 void CCaeTestVideoStates::TestPrepareAndRecordQualityLevel0L()

    67     {

    68 	// ID:      CAE.VR.VIDEORECORDING.QCIF64000FR15.004

    69     //

    70     // Group:   Record.

    71     // 

    72     // Action : Test to prepare video recording and record quality level 0 

    73     //          video clip when initialization is done.

    74 	//      

    75 	// Output : No leave. File cae_novf_ql_0.3gp.  

    76 

    77     iStatesClient->SetVideoQualityLevelIndex( 0 );

    78 

    79     iStatesClient->SetTimeout( 5000000 );

    80     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

    81 

    82     iStatesClient->SetVideoFileName( _L("cae_novf_ql_0.3gp") );

    83 

    84     iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareAndRecordVideo );

    85 

    86     assertL( iStatesClient->CountInitComplete() == 1 );

    87     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

    88     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

    89     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

    90     }

    91 

    92 void CCaeTestVideoStates::TestPrepareAndRecordQualityLevel1L()

    93     {

    94 	// ID:      CAE.VR.VIDEORECORDING.SUBQCIF60000FR15.005

    95     //

    96     // Group:   Record.

    97     // 

    98     // Action : Test to prepare video recording and record quality level 1 

    99     //          video clip when initialization is done.

   100 	//      

   101 	// Output : No leave. File cae_novf_ql_1.3gp.  

   102 

   103     iStatesClient->SetVideoQualityLevelIndex( 1 );

   104 

   105     iStatesClient->SetTimeout( 5000000 );

   106     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   107 

   108     iStatesClient->SetVideoFileName( _L("cae_novf_ql_1.3gp") );

   109 

   110     iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareAndRecordVideo );

   111 

   112     assertL( iStatesClient->CountInitComplete() == 1 );

   113     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   114     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   115     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   116     }

   117 

   118 void CCaeTestVideoStates::TestPrepareAndRecordQualityLevel2L()

   119     {

   120 	// ID:      CAE.VR.VIDEORECORDING.SUBQCIF40000FR5.006

   121     //

   122     // Group:   Record.

   123     // 

   124     // Action : Test to prepare video recording and record quality level 2 

   125     //          video clip when initialization is done.

   126 	//      

   127 	// Output : No leave. File cae_novf_ql_2.3gp.  

   128 

   129     iStatesClient->SetVideoQualityLevelIndex( 2 );

   130 

   131     iStatesClient->SetTimeout( 5000000 );

   132     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   133 

   134     iStatesClient->SetVideoFileName( _L("cae_novf_ql_2.3gp") );

   135 

   136     iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareAndRecordVideo );

   137 

   138     assertL( iStatesClient->CountInitComplete() == 1 );

   139     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   140     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   141     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   142     }

   143 

   144 

   145 /********************************************************/

   146 /*  VIDEO RECORDING SPECIAL PREPARE AND RECORD          */

   147 /********************************************************/

   148 

   149 void CCaeTestVideoStates::TestVideoRecordingQcif60000Fr10NoAudioNoVfL()

   150     {

   151 	// ID: CAE.VR.STARTSTOPVIDEORECORDING.QCIF.003

   152     //

   153     // Group:   Record

   154     // 

   155     // Action : To ensure that the implementation is compatible with camcorder plug-in. 

   156     //          To ensure that starting and stopping video recording works. 

   157     //          To ensure that recording QCIF sized video works. 

   158     //          Video recording prepared for QCIF format.

   159 	//      

   160 	// Output : OK.   

   161 

   162     iStatesClient->SetTimeout( 20000000 );

   163     

   164     TSize sizeQcif( KImgWidthQCIF, KImgHeightQCIF );

   165 

   166     iStatesClient->SetVideoFrameSize( sizeQcif );

   167     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

   168     iStatesClient->SetVideoBitRate( TInt( 60000 ) );

   169     iStatesClient->SetVideoAudio( EFalse );

   170     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   171 

   172     iStatesClient->SetRunningWithViewFinder( EFalse );

   173 

   174     iStatesClient->SetVideoFileName( _L("cae_qcif10fps.3gp") );

   175 

   176     iStatesClient->RunTestActionL( CCaeTestStatesClient::ESpecifiedPrepareAndRecordVideo );

   177 

   178     assertL( iStatesClient->CountInitComplete() == 1 );

   179     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   180     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   181     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   182     }

   183 

   184 void CCaeTestVideoStates::TestVideoRecordingQcif60000Fr10WithAudioNoVfL()

   185     {

   186 	// ID: CAE.VR.STARTSTOPVIDEORECORDING.QCIF.004

   187     //

   188     // Group:   Record

   189     // 

   190     // Action : To ensure that the implementation is compatible with camcorder plug-in. 

   191     //          To ensure that starting and stopping video recording works. 

   192     //          To ensure that recording QCIF sized video works. 

   193     //          Video recording prepared for QCIF format.

   194 	//      

   195 	// Output : OK.   

   196 

   197     iStatesClient->SetTimeout( 20000000 );

   198     

   199     TSize sizeQcif( KImgWidthQCIF, KImgHeightQCIF );

   200 

   201     iStatesClient->SetVideoFrameSize( sizeQcif );

   202     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

   203     iStatesClient->SetVideoBitRate( TInt( 60000 ) );

   204 #if ( defined (__WINS__) || defined (__WINSCW) ) // this different on hw

   205     iStatesClient->SetVideoAudio( EFalse ); // Audio does not work in emulator, error -9

   206 #else

   207     iStatesClient->SetVideoAudio( ETrue );

   208 #endif

   209     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   210 

   211     iStatesClient->SetRunningWithViewFinder( EFalse );

   212 

   213     iStatesClient->SetVideoFileName( _L("cae_qcif10fps_audio.3gp") );

   214 

   215     iStatesClient->RunTestActionL( CCaeTestStatesClient::ESpecifiedPrepareAndRecordVideo );

   216 

   217     assertL( iStatesClient->CountInitComplete() == 1 );

   218     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   219     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   220     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   221     }

   222 

   223 void CCaeTestVideoStates::TestVideoRecordingQcif60000Fr10NoAudioWithVfL()

   224     {

   225 	// ID: CAE.VR.STARTSTOPVIDEORECORDING.QCIF.005

   226     //

   227     // Group:   Record

   228     // 

   229     // Action : To ensure that the implementation is compatible with camcorder plug-in. 

   230     //          To ensure that starting and stopping video recording works. 

   231     //          To ensure that recording QCIF sized video works. 

   232     //          Video recording prepared for QCIF format.

   233 	//      

   234 	// Output : OK.   

   235 

   236     iStatesClient->SetTimeout( 20000000 );

   237     

   238     TSize sizeQcif( KImgWidthQCIF, KImgHeightQCIF );

   239 

   240     iStatesClient->SetVideoFrameSize( sizeQcif );

   241     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

   242     iStatesClient->SetVideoBitRate( TInt( 60000 ) );

   243     iStatesClient->SetVideoAudio( EFalse );

   244     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   245 

   246     iStatesClient->SetViewFinderSize( sizeQcif );

   247     iStatesClient->SetRunningWithViewFinder( ETrue );

   248 

   249     iStatesClient->SetVideoFileName( _L("cae_qcif10fps_vf.3gp") );

   250 

   251     iStatesClient->RunTestActionL( CCaeTestStatesClient::ESpecifiedPrepareAndRecordVideo );

   252 

   253     assertL( iStatesClient->CountInitComplete() == 1 );

   254     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   255     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   256     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   257     }

   258 

   259 void CCaeTestVideoStates::TestVideoRecordingQcif60000Fr10WithAudioWithVfL()

   260     {

   261 	// ID: CAE.VR.STARTSTOPVIDEORECORDING.QCIF.006

   262     //

   263     // Group:   Record

   264     // 

   265     // Action : To ensure that the implementation is compatible with camcorder plug-in. 

   266     //          To ensure that starting and stopping video recording works. 

   267     //          To ensure that recording QCIF sized video works. 

   268     //          Video recording prepared for QCIF format.

   269 	//      

   270 	// Output : OK.   

   271 

   272     iStatesClient->SetTimeout( 20000000 );

   273     

   274     TSize sizeQcif( KImgWidthQCIF, KImgHeightQCIF );

   275 

   276     iStatesClient->SetVideoFrameSize( sizeQcif );

   277     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

   278     iStatesClient->SetVideoBitRate( TInt( 60000 ) );

   279 #if ( defined (__WINS__) || defined (__WINSCW) ) // this different on hw

   280     iStatesClient->SetVideoAudio( EFalse );// Audio does not work in emulator, error -9

   281 #else

   282     iStatesClient->SetVideoAudio( ETrue );

   283 #endif

   284     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   285 

   286     iStatesClient->SetViewFinderSize( sizeQcif );

   287     iStatesClient->SetRunningWithViewFinder( ETrue );

   288 

   289     iStatesClient->SetVideoFileName( _L("cae_qcif10fps_audio_vf.3gp") );

   290 

   291     iStatesClient->RunTestActionL( CCaeTestStatesClient::ESpecifiedPrepareAndRecordVideo );

   292 

   293     assertL( iStatesClient->CountInitComplete() == 1 );

   294     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   295     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   296     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   297     }

   298 

   299 /********************************************************/

   300 /*              PAUSE VIDEO RECORDING                   */

   301 /********************************************************/

   302 

   303 void CCaeTestVideoStates::TestRecordPauseStopL()

   304     {

   305 	// ID:      CAE.VR.PAUSEVIDEORECORDING.001

   306     //

   307     // Group:   Record.

   308     // 

   309     // Action : Pause video clip recording.Video recordin prepared.

   310 	//      

   311 	// Output : No leave. File KVideoFileName, "videoclip.3gp".   

   312 

   313     iStatesClient->SetTimeout( 3000000 );

   314 

   315     iStatesClient->SetVideoQualityLevelIndex( 0 );

   316     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   317 

   318     iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareRecordPauseStopVideo );

   319 

   320     assertL( iStatesClient->CountInitComplete() == 1 );

   321     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   322     assertL( iStatesClient->CountVideoRecordingPaused() == 1 );

   323     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   324     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   325     }

   326 

   327 void CCaeTestVideoStates::TestPauseWhenPreparedL()

   328     {

   329 	// ID:      CAE.VR.PAUSEVIDEORECORDING.002

   330     //

   331     // Group:   Record.

   332     // 

   333     // Action : Call Pause when video is prepared but video recordind is not started.

   334 	//      

   335 	// Output : Leave..   

   336 

   337     iStatesClient->SetTimeout( 5000000 );

   338 

   339     iStatesClient->SetVideoQualityLevelIndex( 0 );

   340     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   341 

   342     TRAPD( err, iStatesClient->RunTestActionL( CCaeTestStatesClient::EPauseVideoWhenPrepared ) );

   343     assertL( err == KErrNotReady );

   344 

   345     assertL( iStatesClient->CountInitComplete() == 1 );

   346     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   347     assertL( iStatesClient->CountVideoRecordingPaused() == 1 );

   348     assertL( iStatesClient->CountVideoRecordingOn() == 0 );

   349     assertL( iStatesClient->CountVideoRecordingComplete() == 0 );

   350     }

   351 

   352 void CCaeTestVideoStates::TestRecordPausePauseStopL()

   353     {

   354 	// ID:      CAE.VR.PAUSEVIDEORECORDING.003

   355     //

   356     // Group:   Record.

   357     // 

   358     // Action : Pause video clip recording twice.Video recordin prepared.

   359 	//      

   360 	// Output : No leave. File KVideoFileName, "videoclip.3gp".   

   361 

   362     iStatesClient->SetTimeout( 3000000 );

   363 

   364     iStatesClient->SetVideoQualityLevelIndex( 0 );

   365     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   366 

   367     iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareRecordPausePauseStopVideo );

   368 

   369     assertL( iStatesClient->CountInitComplete() == 1 );

   370     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   371     assertL( iStatesClient->CountVideoRecordingPaused() == 2 );

   372     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   373     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   374     }

   375 

   376 /********************************************************/

   377 /*              RESUME VIDEO RECORDING                  */

   378 /********************************************************/

   379 

   380 void CCaeTestVideoStates::TestResumeWhenPreparedL()

   381     {

   382 	// ID:      CAE.VR.RESUMEVIDEORECORDING.002

   383     //

   384     // Group:   Record.

   385     // 

   386     // Action : Resume video clip recording before pause. 

   387     //          Video recording.

   388 	//      

   389 	// Output : Leave.   

   390 

   391     iStatesClient->SetTimeout( 3000000 );

   392 

   393     iStatesClient->SetVideoQualityLevelIndex( 0 );

   394 

   395     iStatesClient->SetVideoFileName( _L("cae_pause_resume.3gp") );

   396     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   397 

   398     TRAPD( err, iStatesClient->RunTestActionL( CCaeTestStatesClient::EResumeVideoWhenPrepared ) );

   399     assertL( err == KErrNotReady );

   400 

   401     assertL( iStatesClient->CountInitComplete() == 1 );

   402     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   403     }

   404 

   405 void CCaeTestVideoStates::TestResumeWhenNotPausedL()

   406     {

   407 	// ID:      CAE.VR.RESUMEVIDEORECORDING.003

   408     //

   409     // Group:   Record.

   410     // 

   411     // Action : Resume video clip recording before pause. 

   412     //          Video recording.

   413 	//      

   414 	// Output : Leave.   

   415 

   416     iStatesClient->SetTimeout( 5000000 );

   417 

   418     iStatesClient->SetVideoQualityLevelIndex( 0 );

   419 

   420     iStatesClient->SetVideoFileName( _L("cae_pause_resume.3gp") );

   421     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   422 

   423     TRAPD( err, iStatesClient->RunTestActionL( CCaeTestStatesClient::EResumeVideoWhenNotPaused ) );

   424     assertL( err == KErrNotReady );

   425 

   426     assertL( iStatesClient->CountInitComplete() == 1 );

   427     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   428     assertL( iStatesClient->CountVideoRecordingPaused() == 0 );

   429     assertL( iStatesClient->CountVideoRecordingOn() == 2 );

   430     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   431     }

   432 

   433 /********************************************************/

   434 /*              PREPARE VIDEO RECORDING                 */

   435 /********************************************************/

   436 

   437 void CCaeTestVideoStates::TestPrepareVideoRecordingNeg1L()

   438     {

   439 	// ID: CAE.VR.PREPAREVIDEORECORDINGL.005

   440     //

   441     // Group:   Record

   442     // 

   443     // Action : Try to prepare the engine for video recording using invalid quality level index. 

   444     //          Initialization is done.

   445 	//      

   446 	// Output : Leave.   

   447 

   448     iStatesClient->SetVideoQualityLevelIndex( -1 );

   449     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   450 

   451     //iStatesClient->SetVideoFileName( _L("cae_prepare_vr_-1.3gp") );

   452 

   453     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareVideoRecording ) );

   454     assertL( error != KErrNone );

   455 

   456     assertL( iStatesClient->CountInitComplete() == 1 );

   457     assertL( iStatesClient->CountVideoPrepareComplete() == 0 );

   458     }

   459 

   460 void CCaeTestVideoStates::TestPrepareVideoRecording3L()

   461     {

   462 	// ID: CAE.VR.PREPAREVIDEORECORDINGL.006

   463     //

   464     // Group:   Record

   465     // 

   466     // Action : Try to prepare the engine for video recording using invalid quality level index. 

   467     //          Initialization is done.

   468 	//      

   469 	// Output : Leave.   

   470 

   471     iStatesClient->SetVideoQualityLevelIndex( 3 );

   472     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   473 

   474     //iStatesClient->SetVideoFileName( _L("cae_prepare_vr_3.3gp") );

   475 

   476     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareVideoRecording ) );

   477     assertL( error != KErrNone );

   478 

   479     assertL( iStatesClient->CountInitComplete() == 1 );

   480     assertL( iStatesClient->CountVideoPrepareComplete() == 0 );

   481     }

   482 

   483 void CCaeTestVideoStates::TestSpecPrepareVRUnsupportedFormatWhenVRInitializedL()

   484 {

   485     // ID: CAE.VR.PREPAREVIDEORECORDINGL.008

   486     //

   487     // Group:   Record.

   488     // 

   489     // Action : Set video recording format to a format unsupported by MMF Camcorder plug-in 

   490     //          and Camera API implementation. 

   491     //          Video recorder initialization is done.

   492 	//      

   493 	// Output : Leave.    

   494 

   495     iStatesClient->SetTimeout( 3000000 );

   496 

   497     TSize sizeTooBig( KImgWidthTooBig, KImgHeightTooBig );

   498     iStatesClient->SetVideoFrameSize( sizeTooBig );

   499     iStatesClient->SetVideoFrameRate( 10.0 );

   500     iStatesClient->SetVideoBitRate( 50000 );

   501     iStatesClient->SetVideoAudio( ETrue );

   502     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   503 

   504     //iStatesClient->SetVideoFileName( _L("cae_video_unsupported_format.3gp") );

   505 

   506     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::ESpecifiedPrepareVideo ) );//verified if is correct action

   507     assertL( error != KErrNone );

   508 

   509     assertL( iStatesClient->CountInitComplete() == 1 );

   510     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   511     }

   512 

   513 void CCaeTestVideoStates::TestSpecPrepareVRSupportedFormatWhenPreparedL()

   514 {

   515     // ID: CAE.VR.PREPAREVIDEORECORDINGL.009

   516     //

   517     // Group:   Record.

   518     // 

   519     // Action : Set video recording format to a format supported by MMF Camcorder plug-in 

   520     //          and Camera API implementation when video recording is prepared already. .

   521 	//      

   522 	// Output : OK.    

   523 

   524     iStatesClient->SetTimeout( 5000000 );

   525 

   526     TSize sizeSubqcif( KImgWidthSubQCIF, KImgHeightSubQCIF );

   527     iStatesClient->SetVideoFrameSize( sizeSubqcif );

   528     iStatesClient->SetVideoFrameRate( 10.0 );

   529     iStatesClient->SetVideoBitRate( 50000 );

   530     iStatesClient->SetVideoAudio( ETrue );

   531     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   532 

   533     //iStatesClient->SetVideoFileName( _L("cae_video_format_prepared.3gp") );

   534 

   535     iStatesClient->RunTestActionL( CCaeTestStatesClient::ESpecifiedPrepareVideoWhenPrepared );//verified if is correct action

   536 

   537     assertL( iStatesClient->CountInitComplete() == 1 );

   538     assertL( iStatesClient->CountVideoPrepareComplete() == 2 );

   539     }

   540 

   541 /********************************************************/

   542 /*              START VIDEO RECORDING                   */

   543 /********************************************************/

   544 

   545 void CCaeTestVideoStates::TestStartVideoRecordingWhenVRInitializedL()

   546     {

   547 	// ID: CAE.VR.STARTVIDEORECORDING.001

   548     //

   549     // Group:   Record

   550     // 

   551     // Action : Start video clip recording. 

   552     //          Initialization is done.

   553 	//      

   554 	// Output : Leave.   

   555 

   556     iStatesClient->SetTimeout( 3000000 );

   557     

   558     iStatesClient->SetVideoQualityLevelIndex( 0 );

   559     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   560 

   561     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EStartVideoRecordingWhenInitialized ) );//we have to put correct action

   562     assertL( error == KErrNotReady );

   563     

   564     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   565     }

   566 

   567 void CCaeTestVideoStates::TestStartVideoRecordingWhenRecordingL()

   568     {

   569 	// ID: CAE.VR.STARTVIDEORECORDING.002

   570     //

   571     // Group:   Record

   572     // 

   573     // Action : Start video clip recording. 

   574     //          Video recording on.

   575 	//      

   576 	// Output : Leave.   

   577 

   578     iStatesClient->SetTimeout( 3000000 );

   579     

   580     iStatesClient->SetVideoQualityLevelIndex( 0 );

   581     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   582 

   583     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EStartVideoRecordingWhenRecording ) );//we have to put correct action

   584     assertL( error == KErrNotReady );

   585     

   586     assertL( iStatesClient->CountVideoRecordingOn() == 2 );

   587     }

   588 

   589 /********************************************************/

   590 /*              STOP VIDEO RECORDING                    */

   591 /********************************************************/

   592 

   593 void CCaeTestVideoStates::TestStopVideoRecordingWhenVRInitializedL()

   594     {

   595 	// ID: CAE.VR.STOPVIDEORECORDING.001

   596     //

   597     // Group:   Record

   598     // 

   599     // Action : Stop video clip recording. 

   600     //          Initialization is done.

   601 	//      

   602 	// Output : Leave.   

   603 

   604     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   605     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EStopVideoRecordingWhenInitialized ) );//we have to put correct action

   606     assertL( error == KErrNotReady );

   607     

   608     assertL( iStatesClient->CountInitComplete() == 1 );

   609     assertL( iStatesClient->CountVideoRecordingOn() == 0 );

   610     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   611     }

   612 

   613 void CCaeTestVideoStates::TestStopVideoRecordingWhenPreparedL()

   614     {

   615 	// ID: CAE.VR.STOPVIDEORECORDING.002

   616     //

   617     // Group:   Record

   618     // 

   619     // Action : Stop video clip recording. 

   620     //          Video recording prepared.

   621 	//      

   622 	// Output : Leave.   

   623 

   624     iStatesClient->SetVideoQualityLevelIndex( 0 );

   625     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   626 

   627     //iStatesClient->SetVideoFileName( _L("cae_stop_vr_prepared.3gp") );

   628 

   629     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EStopVideoRecordingWhenPrepared ) );//we have to put correct action

   630     assertL( error == KErrNotReady );

   631     

   632     assertL( iStatesClient->CountInitComplete() == 1 );

   633     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   634     assertL( iStatesClient->CountVideoRecordingOn() == 0 );

   635     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   636     }

   637 

   638 /********************************************************/

   639 /*                    STATE CHANGE                      */

   640 /********************************************************/

   641 

   642 void CCaeTestVideoStates::TestCaptureRecordL()

   643     {

   644 	// ID:      CAE.STATECHANGE.CAPTURERECORD.002

   645     //

   646     // Group:   Capture & Record.

   647     // 

   648     // Action : Capture photo first and then record video successively

   649 	//      

   650 	// Output : No leave.    

   651 

   652     iStatesClient->SetTimeout( 1000000 );

   653 

   654     iStatesClient->SetVideoQualityLevelIndex( 0 );

   655 

   656     iStatesClient->SetStillQualityLevelIndex( 0 );

   657     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   658 

   659     iStatesClient->RunTestActionL( CCaeTestStatesClient::ECaptureRecord );

   660 

   661     assertL( iStatesClient->CountInitComplete() == 1 );

   662 

   663     assertL( iStatesClient->CountStillPrepareComplete() == 1 );

   664     assertL( iStatesClient->CountSnapImageReady() == 1 );

   665     assertL( iStatesClient->CountStillImageReady() == 1 );

   666 

   667     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   668     assertL( iStatesClient->CountVideoRecordingPaused() == 0 );

   669     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   670     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   671     }

   672 

   673 void CCaeTestVideoStates::TestRecordCaptureL()

   674     {

   675 	// ID:      CAE.STATECHANGE.RECORDCAPTURE.003

   676     //

   677     // Group:   Record & Capture.

   678     // 

   679     // Action : Record video first and then capture photo successively

   680 	//      

   681 	// Output : No leave.    

   682 

   683     iStatesClient->SetTimeout( 1000000 );

   684 

   685     iStatesClient->SetVideoQualityLevelIndex( 0 );

   686 

   687     iStatesClient->SetStillQualityLevelIndex( 0 );

   688     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   689 

   690     iStatesClient->RunTestActionL( CCaeTestStatesClient::ERecordCapture );

   691 

   692     assertL( iStatesClient->CountInitComplete() == 1 );

   693 

   694     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   695     assertL( iStatesClient->CountVideoRecordingPaused() == 0 );

   696     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   697     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   698 

   699     assertL( iStatesClient->CountStillPrepareComplete() == 1 );

   700     assertL( iStatesClient->CountSnapImageReady() == 1 );

   701     assertL( iStatesClient->CountStillImageReady() == 1 );

   702     }

   703 

   704 void CCaeTestVideoStates::TestRecordRecordL()

   705     {

   706 	// ID:      CAE.STATECHANGE.RECORDRECORD.004

   707     //

   708     // Group:   Record.

   709     // 

   710     // Action : Record video two times successively

   711 	//      

   712 	// Output : No leave.    

   713 

   714     iStatesClient->SetTimeout( 2000000 );

   715 

   716     iStatesClient->SetVideoQualityLevelIndex( 0 );

   717     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   718 

   719     iStatesClient->RunTestActionL( CCaeTestStatesClient::ERecordRecord );

   720 

   721     assertL( iStatesClient->CountInitComplete() == 1 );

   722 

   723     // This should equal 2 because before 2nd recording we change the file name 

   724     // and it needs preparation.

   725     assertL( iStatesClient->CountVideoPrepareComplete() == 2 );

   726 

   727     assertL( iStatesClient->CountVideoRecordingPaused() == 0 );

   728     assertL( iStatesClient->CountVideoRecordingOn() == 2 );

   729     assertL( iStatesClient->CountVideoRecordingComplete() == 2 );

   730     }

   731 

   732 

   733 void CCaeTestVideoStates::TestRecordCaptureComplexSequence1L()

   734     {

   735 	// ID:      CAE.STATECHANGE.RECORDCAPTURECOMPLEX1.005

   736     //

   737     // Group:   Record.

   738     // 

   739     // Action : Record and capture multiple times successively

   740 	//      

   741 	// Output : No leave.    

   742 

   743     iStatesClient->SetTimeout( 15000000 );

   744 

   745     iStatesClient->SetVideoQualityLevelIndex( 0 );

   746 

   747     iStatesClient->SetStillQualityLevelIndex( 0 );

   748 

   749     iStatesClient->SetVideoClipMaxSize( 10000 );

   750     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   751 

   752     iStatesClient->RunTestActionL( CCaeTestStatesClient::ERecordCaptureComplexSequence1 );

   753 

   754     assertL( iStatesClient->CountInitComplete() == 2 );

   755     assertL( iStatesClient->CountStillPrepareComplete() == 2 );

   756     assertL( iStatesClient->CountVideoPrepareComplete() == 7 );

   757     assertL( iStatesClient->CountVideoRecordingOn() == 7 );

   758     assertL( iStatesClient->CountVideoRecordingComplete() == 7 );

   759     assertL( iStatesClient->CountSnapImageReady() == 2 );

   760     assertL( iStatesClient->CountStillImageReady() == 2 );

   761     }

   762 

   763 

   764 void CCaeTestVideoStates::TestRecordCaptureComplexSequence2L()

   765     {

   766 	// ID:      CAE.STATECHANGE.RECORDCAPTURECOMPLEX2.006

   767     //

   768     // Group:   Record.

   769     // 

   770     // Action : Record and capture multiple times successively. Contains also still bursts!

   771 	//      

   772 	// Output : No leave.    

   773 

   774     const TInt KStillBurstLength = 3;

   775 

   776     iStatesClient->SetSnapFileName( _L("cae_complex2.mbm") );

   777 

   778     iStatesClient->SetStillFileName( _L("cae_complex2.jpg") );

   779 

   780     iStatesClient->SetStillBurstLength( KStillBurstLength );

   781 

   782     iStatesClient->SetTimeout( 15000000 );

   783 

   784     iStatesClient->SetVideoQualityLevelIndex( 0 );

   785 

   786     iStatesClient->SetStillQualityLevelIndex( 0 );

   787     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   788 

   789     iStatesClient->SetVideoClipMaxSize( 10000 );

   790 

   791     iStatesClient->RunTestActionL( CCaeTestStatesClient::ERecordCaptureComplexSequence2 );

   792 

   793     assertL( iStatesClient->CountInitComplete() == 1 );

   794     assertL( iStatesClient->CountStillPrepareComplete() == 2 );

   795     assertL( iStatesClient->CountVideoPrepareComplete() == 4 /*3*/ );

   796     assertL( iStatesClient->CountVideoRecordingOn() == 4 );

   797     assertL( iStatesClient->CountVideoRecordingComplete() == 4 );

   798     assertL( iStatesClient->CountSnapImageReady() == ( ( 2 * KStillBurstLength ) + 3 ) );

   799     assertL( iStatesClient->CountStillImageReady() == ( ( 2 * KStillBurstLength ) + 3 ) );

   800 

   801     assertL( iStatesClient->CountStillBurstCaptureMoment() == ( 2 * KStillBurstLength ) );

   802     assertL( iStatesClient->CountStillBurstComplete() == 2 );

   803     }

   804 

   805 

   806 void CCaeTestVideoStates::TestReleaseReserveRecordL()

   807     {

   808     // ID: CAE.GEN.RELESEANDRESERVE.006

   809 	//

   810     // General

   811     // 

   812     // Action : Try to re-reserve the camera module after initial reservation

   813     //          and releasing. Then capture still image.

   814 	//      

   815 	// Output : OK.   

   816 

   817     iStatesClient->SetTimeout( 3000000 );

   818 

   819     iStatesClient->SetVideoQualityLevelIndex( 2 );

   820     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   821 

   822     iStatesClient->SetVideoFileName( _L("cae_relres_ql_2.3gp") );

   823 

   824     iStatesClient->RunTestActionL( CCaeTestStatesClient::EReleaseReserveRecord );

   825 

   826     assertL( iStatesClient->CountInitComplete() == 2 );

   827     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   828     assertL( iStatesClient->CountVideoRecordingPaused() == 0 );

   829     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   830     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   831     }

   832 

   833 

   834 /********************************************************/

   835 /*                "DESTROY ENGINE"-TESTS                */

   836 /********************************************************/

   837 

   838 

   839 void CCaeTestVideoStates::TestDestroy1L()

   840     {

   841 	// ID: CAE.VR.DESTROY.001

   842     //

   843     // Group:   Record

   844     // 

   845     // Action : Test to destroy the engine when video is prepared.

   846 	//      

   847 	// Output : OK.   

   848 

   849     iStatesClient->SetTimeout( 10000000 );

   850     

   851     TSize sizeQcif( KImgWidthQCIF, KImgHeightQCIF );

   852 

   853     iStatesClient->SetVideoFrameSize( sizeQcif );

   854     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

   855     iStatesClient->SetVideoBitRate( TInt( 60000 ) );

   856     iStatesClient->SetVideoAudio( EFalse );

   857     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   858 

   859     iStatesClient->SetRunningWithViewFinder( ETrue );

   860 

   861     iStatesClient->RunTestActionL( CCaeTestStatesClient::EDestroyEngineWhenVideoPrepareReady );

   862 

   863     assertL( iStatesClient->CountInitComplete() == 1 );

   864     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   865     assertL( iStatesClient->CountVideoRecordingOn() == 0 );

   866     assertL( iStatesClient->CountVideoRecordingPaused() == 0 );

   867     assertL( iStatesClient->CountVideoRecordingComplete() == 0 );

   868     }

   869 

   870 

   871 void CCaeTestVideoStates::TestDestroy2L()

   872     {

   873 	// ID: CAE.VR.DESTROY.002

   874     //

   875     // Group:   Record

   876     // 

   877     // Action : Test to destroy the engine when video recording is on.

   878 	//      

   879 	// Output : OK.   

   880 

   881     iStatesClient->SetTimeout( 10000000 );

   882     

   883     TSize sizeQcif( KImgWidthQCIF, KImgHeightQCIF );

   884 

   885     iStatesClient->SetVideoFrameSize( sizeQcif );

   886     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

   887     iStatesClient->SetVideoBitRate( TInt( 60000 ) );

   888     iStatesClient->SetVideoAudio( EFalse );

   889     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   890 

   891     iStatesClient->SetRunningWithViewFinder( ETrue );

   892 

   893     iStatesClient->RunTestActionL( CCaeTestStatesClient::EDestroyEngineWhenVideoRecordingOn );

   894 

   895     assertL( iStatesClient->CountInitComplete() == 1 );

   896     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   897     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   898     assertL( iStatesClient->CountVideoRecordingPaused() == 0 );

   899     assertL( iStatesClient->CountVideoRecordingComplete() == 0 );

   900     }

   901 

   902 

   903 void CCaeTestVideoStates::TestDestroy3L()

   904     {

   905 	// ID: CAE.VR.DESTROY.003

   906     //

   907     // Group:   Record

   908     // 

   909     // Action : Test to destroy the engine when video recording is paused.

   910 	//      

   911 	// Output : OK.   

   912 

   913     iStatesClient->SetTimeout( 10000000 );

   914     

   915     TSize sizeQcif( KImgWidthQCIF, KImgHeightQCIF );

   916 

   917     iStatesClient->SetVideoFrameSize( sizeQcif );

   918     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

   919     iStatesClient->SetVideoBitRate( TInt( 60000 ) );

   920     iStatesClient->SetVideoAudio( EFalse );

   921     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   922 

   923     iStatesClient->SetRunningWithViewFinder( ETrue );

   924 

   925     iStatesClient->RunTestActionL( CCaeTestStatesClient::EDestroyEngineWhenVideoRecordingPaused );

   926 

   927     assertL( iStatesClient->CountInitComplete() == 1 );

   928     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   929     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   930     assertL( iStatesClient->CountVideoRecordingPaused() == 1 );

   931     assertL( iStatesClient->CountVideoRecordingComplete() == 0 );

   932     }

   933 

   934 

   935 void CCaeTestVideoStates::TestDestroy4L()

   936     {

   937 	// ID: CAE.VR.DESTROY.004

   938     //

   939     // Group:   Record

   940     // 

   941     // Action : Test to destroy the engine when video recording is completed.

   942 	//      

   943 	// Output : OK.   

   944 

   945     iStatesClient->SetTimeout( 10000000 );

   946     

   947     TSize sizeQcif( KImgWidthQCIF, KImgHeightQCIF );

   948 

   949     iStatesClient->SetVideoFrameSize( sizeQcif );

   950     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

   951     iStatesClient->SetVideoBitRate( TInt( 60000 ) );

   952     iStatesClient->SetVideoAudio( EFalse );

   953     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   954 

   955     iStatesClient->SetRunningWithViewFinder( ETrue );

   956 

   957     iStatesClient->RunTestActionL( CCaeTestStatesClient::EDestroyEngineWhenVideoRecordingReady );

   958 

   959     assertL( iStatesClient->CountInitComplete() == 1 );

   960     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   961     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

   962     assertL( iStatesClient->CountVideoRecordingPaused() == 0 );

   963     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

   964     }

   965 

   966 

   967 /********************************************************/

   968 /*                ERROR SIMULATIONS                     */

   969 /********************************************************/

   970 

   971 void CCaeTestVideoStates::TestVideoRecorderOpenErrorL()

   972     {

   973 	// ID:      CAE.VR.ERRORS.001

   974     //

   975     // Group:   Errors.

   976     // 

   977     // Action : Test error handling with video recorder opening.

   978 	//      

   979 	// Output : Leave with code KErrAbort.

   980 

   981     iStatesClient->SetVideoQualityLevelIndex( 0 );

   982     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

   983 

   984     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EVideoRecorderOpenError ) );

   985     assertL( error == KErrAbort );

   986 

   987     assertL( iStatesClient->CountInitComplete() == 1 );

   988     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

   989     assertL( iStatesClient->CountVideoRecordingOn() == 0 );

   990     assertL( iStatesClient->CountVideoRecordingComplete() == 0 );

   991     }

   992 

   993 

   994 void CCaeTestVideoStates::TestVideoRecorderPrepareErrorL()

   995     {

   996 	// ID:      CAE.VR.ERRORS.002

   997     //

   998     // Group:   Errors.

   999     // 

  1000     // Action : Test error handling with video recorder preparation.

  1001 	//      

  1002 	// Output : Leave with code KErrAbort.

  1003 

  1004     iStatesClient->SetVideoQualityLevelIndex( 0 );

  1005     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

  1006 

  1007     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EVideoRecorderPrepareError ) );

  1008     assertL( error == KErrAbort );

  1009 

  1010     assertL( iStatesClient->CountInitComplete() == 1 );

  1011     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

  1012     assertL( iStatesClient->CountVideoRecordingOn() == 0 );

  1013     assertL( iStatesClient->CountVideoRecordingComplete() == 0 );

  1014     }

  1015 

  1016 

  1017 void CCaeTestVideoStates::TestVideoRecordingCompleteErrorL()

  1018     {

  1019 	// ID:      CAE.VR.ERRORS.003

  1020     //

  1021     // Group:   Errors.

  1022     // 

  1023     // Action : Test error handling with video recording completion.

  1024 	//      

  1025 	// Output : Leave with code KErrAbort.

  1026 

  1027     iStatesClient->SetVideoQualityLevelIndex( 0 );

  1028 

  1029     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EVideoRecordingCompleteError ) );

  1030     assertL( error == KErrAbort );

  1031 

  1032     assertL( iStatesClient->CountInitComplete() == 1 );

  1033     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

  1034     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

  1035     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

  1036     }

  1037 

  1038 

  1039 void CCaeTestVideoStates::TestPrepareVideoSettingsErrorL()

  1040     {

  1041 	// ID:      CAE.VR.ERRORS.004

  1042     //

  1043     // Group:   Errors.

  1044     // 

  1045     // Action : Test error handling with video recorder settings preparation.

  1046 	//      

  1047 	// Output : Leave with code KErrAbort.

  1048 

  1049     iStatesClient->SetVideoQualityLevelIndex( 0 );

  1050     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

  1051 

  1052     TRAPD( error, iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareVideoSettingsError ) );

  1053     assertL( error == KErrAbort );

  1054 

  1055     assertL( iStatesClient->CountInitComplete() == 1 );

  1056     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

  1057     assertL( iStatesClient->CountVideoRecordingOn() == 0 );

  1058     assertL( iStatesClient->CountVideoRecordingComplete() == 0 );

  1059     }

  1060 

  1061 /********************************************************/

  1062 /*      PREPARE AUDIO BIT RATE AND RECORD VIDEO         */

  1063 /********************************************************/

  1064 

  1065 void CCaeTestVideoStates::TestPrepareAudioBitRateVR0L()

  1066     {

  1067 	// ID: CAE.VR.PREPAREAUDIOBITRATEANDRECORDVIDEO.002

  1068     //

  1069     // Group:   Record

  1070     // 

  1071     // Action : To ensure that the implementation is compatible with camcorder plug-in. 

  1072 	//      

  1073 	// Output : OK.   

  1074 

  1075     iStatesClient->SetTimeout( 4000000 );

  1076 

  1077     TSize sizeSubQcif( KImgWidthSubQCIF, KImgHeightSubQCIF );

  1078 

  1079     iStatesClient->SetVideoFrameSize( sizeSubQcif );

  1080     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

  1081     iStatesClient->SetVideoBitRate( TInt( 25000 ) );

  1082     

  1083     iStatesClient->SetAudioBitRate( TInt( 0 ) );

  1084     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

  1085 

  1086     iStatesClient->SetVideoFileName( _L("cae_subqcif_AudioBitRate_0.3gp") );

  1087 

  1088     TRAPD( err, iStatesClient->RunTestActionL( CCaeTestStatesClient::ESpecifiedPrepareAudioBrAndRecordVideo ) );

  1089     assertL( err == KErrArgument );

  1090 

  1091     assertL( iStatesClient->CountInitComplete() == 1 );

  1092     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

  1093     assertL( iStatesClient->CountVideoRecordingOn() == 0 );

  1094     assertL( iStatesClient->CountVideoRecordingComplete() == 0 );

  1095     }

  1096 

  1097 void CCaeTestVideoStates::TestPrepareAudioBitRateVR5150L()

  1098     {

  1099 	// ID: CAE.VR.PREPAREAUDIOBITRATEANDRECORDVIDEO.003

  1100     //

  1101     // Group:   Record

  1102     // 

  1103     // Action : To ensure that the implementation is compatible with camcorder plug-in. 

  1104 	//      

  1105 	// Output : OK.   

  1106 

  1107     iStatesClient->SetTimeout( 4000000 );

  1108 

  1109     TSize sizeSubQcif( KImgWidthSubQCIF, KImgHeightSubQCIF );

  1110 

  1111     iStatesClient->SetVideoFrameSize( sizeSubQcif );

  1112     iStatesClient->SetVideoFrameRate( TReal32( 10.0 ) );

  1113     iStatesClient->SetVideoBitRate( TInt( 25000 ) );

  1114     

  1115     iStatesClient->SetAudioBitRate( TInt( 5150 ) );

  1116     iStatesClient->SetVideoCodecSet( 0 ); // 0: AMR audio, H.263 video

  1117 

  1118     iStatesClient->SetVideoFileName( _L("cae_subqcif_AudioBitRate_5150.3gp") );

  1119 

  1120     iStatesClient->RunTestActionL( CCaeTestStatesClient::ESpecifiedPrepareAudioBrAndRecordVideo );

  1121 

  1122     assertL( iStatesClient->CountInitComplete() == 1 );

  1123     assertL( iStatesClient->CountVideoPrepareComplete() == 1 );

  1124     assertL( iStatesClient->CountVideoRecordingOn() == 1 );

  1125     assertL( iStatesClient->CountVideoRecordingComplete() == 1 );

  1126     }

  1127 

  1128 void CCaeTestVideoStates::TestPrepareAudioBitRateVR12200L()

  1129     {

  1130 	// ID: CAE.VR.PREPAREAUDIOBITRATEANDRECORDVIDEO.004

  1131     //

  1132     // Group:   Record

  1133     // 

  1134     // Action : To ensure that the implementation is compatible with camcorder plug-in.