/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: CaeTestStillStates.cpp

*

*/

#include "CaeTestStillStates.h"

#include <f32file.h>

/*

#if ( defined (__WINS__) || defined (__WINSCW) )

_LIT(KProcessFileName, "c:\\stillstates.dat");

#else

_LIT(KProcessFileName, "e:\\stillstates.dat");

#endif

*/

//const TReal32 KViewFinderFrameFrequencyMinimum = 13.0;

CCaeTestStillStates::CCaeTestStillStates ()

    {

    }

CCaeTestStillStates::~CCaeTestStillStates ()

    {

    }

void CCaeTestStillStates::setUpL ()

    {

	iStatesClient = CCaeTestStatesClient::NewL();

    iStatesClient->SetFileNameBase( KFileNameBase );

    }

void CCaeTestStillStates::tearDown ()

    {

    delete iStatesClient;    

    iStatesClient = 0;

    }

//

// Own test functions.

//

// The framework will do for a test function:

//

// setUpL();

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

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

// tearDown();

//

/********************************************************/

/*               PREPARE STILL CAPTURE                  */

/********************************************************/

void CCaeTestStillStates::TestPrepareStillCaptureNeg1L()

    {

	// ID: CAE.SC.PREPARESTILLCAPTUREL.005

    //

    // Group:   Capture

    // 

    // Action : Try to prepare the engine for still image capture using invalid quality level index. 

    //          Initialization is done.

	//      

	// Output : Leave.   

    iStatesClient->SetStillQualityLevelIndex( -1 );

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

    assertL( error != KErrNone );

    }

void CCaeTestStillStates::TestPrepareStillCapture3L()

    {

	// ID: CAE.SC.PREPARESTILLCAPTUREL.006

    //

    // Group:   Capture

    // 

    // Action : Try to prepare the engine for still image capture using invalid quality level index. 

    //          Initialization is done.

	//      

	// Output : Leave.   

    iStatesClient->SetStillQualityLevelIndex( 3 );

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

    assertL( error != KErrNone );

    }

void CCaeTestStillStates::TestSpecPrepareSCUnsupportedFormatWhenInitializedL()

    {

	// ID: CAE.SC.PREPARESTILLCAPTUREL.008

    //

    // Group:   Capture

    // 

    // Action : Set still image capturing format to a format unsupported by Camera API implementation. 

	//          Initialization is done.

    //

	// Output : Leave.   

    iStatesClient->SetStillFormat( CCamera::EFormatFbsBitmapColor16M );

    TSize sizeVga( KImgWidthTooBig, KImgHeightTooBig );

    iStatesClient->SetStillFrameSize( sizeVga );

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

    assertL( error != KErrNone );

    }

void CCaeTestStillStates::TestSpecPrepareSCSupportedFormatWhenPreparedL()

    {

	// ID: CAE.SC.PREPARESTILLCAPTUREL.009

    //

    // Group:   Capture

    // 

    // Action : Set still image capturing format to a format supported by Camera API implementation. 

	//          Still Capture prepared.

    //

	// Output : OK.   

    iStatesClient->SetStillFormat( CCamera::EFormatFbsBitmapColor16M );

    TSize sizeVga( KImgWidthVGA, KImgHeightVGA );

    iStatesClient->SetStillFrameSize( sizeVga );

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

    }

void CCaeTestStillStates::TestPrepareCroppedStillCapturingL()

    {

	// ID: CAE.SC.PREPARESTILLCAPTUREL.011

    //

    // Group:   Capture

    // 

    // Action : 

	//      

	// Output : Leave.   

    iStatesClient->SetStillQualityLevelIndex( 1 );

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

    assertL( error == KErrNotSupported );

    }

void CCaeTestStillStates::TestPrepareStillCaptureWhenPowerOffL()

    {

	// ID: CAE.SC.PREPARESTILLCAPTUREL.011

    //

    // Group:   Capture

    // 

    // Action : Prepare still capture when init is not ready

	//      

	// Output : Leave.   

    iStatesClient->SetStillQualityLevelIndex( 1 );

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

    assertL( error == KErrNotReady );

    }

void CCaeTestStillStates::TestPrepareStillCaptureWhenRecordingL()

    {

	// ID: CAE.SC.PREPARESTILLCAPTUREL.012

    //

    // Group:   Capture

    // 

    // Action : Prepare still capture when recording

	//      

	// Output : Leave.   

    iStatesClient->SetStillQualityLevelIndex( 1 );

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

    assertL( error == KErrNotReady );

    }

void CCaeTestStillStates::TestPrepareStillCaptrureWrongSizeL()

    {

	// ID: CAE.SC.PREPARESTILLCAPTUREL.013

    //

    // Group:   Capture

    // 

    // Action : Set still image capturing format to a format unsupported by Camera API implementation. 

	//          Initialization is done.

    //

	// Output : Leave.   

    iStatesClient->SetStillFormat( CCamera::EFormatFbsBitmapColor16M );

    TSize wrongSize( 600, 400 );

    iStatesClient->SetStillFrameSize( wrongSize );

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

    assertL( error == KErrNotSupported );

    }

/********************************************************/

/*                 STATE CHANGE                         */

/********************************************************/

void CCaeTestStillStates::TestReleaseL()

    {

    // ID: CAE.GEN.RELESEANDRESERVE.002

	//

    // General

    // 

    // Action : Try to release the camera module.

	//      

	// Output : OK.   

    iStatesClient->RunTestActionL( CCaeTestStatesClient::ERelease );

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

    }

void CCaeTestStillStates::TestReleaseReleaseL()

    {

    // ID: CAE.GEN.RELESEANDRESERVE.003

	//

    // General

    // 

    // Action : Try to release the camera module twice.

	//      

	// Output : OK.   

    iStatesClient->RunTestActionL( CCaeTestStatesClient::EReleaseRelease);

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

    }

void CCaeTestStillStates::TestReserveL()

    {

    // ID: CAE.GEN.RELESEANDRESERVE.004

	//

    // General

    // 

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

	//      

	// Output : OK.   

    iStatesClient->RunTestActionL( CCaeTestStatesClient::EReserveReserve );

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

    }

void CCaeTestStillStates::TestReleaseReserveCaptureL()

    {

    // ID: CAE.GEN.RELESEANDRESERVE.005

	//

    // General

    // 

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

    //          and releasing. Then capture still image.

	//      

	// Output : OK.   

    iStatesClient->SetStillQualityLevelIndex( 0 );

    iStatesClient->SetStillFileName( _L("cae_relres_ql_2.jpg") );

    iStatesClient->RunTestActionL( CCaeTestStatesClient::EReleaseReserveCapture );

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

    }

/********************************************************/

/*                GENERAL TESTS                         */

/********************************************************/

void CCaeTestStillStates::TestPowerOffPowerOffL()

    {

    // ID: CAE.GEN.POWEROFFPOWEROFF.001

	//

    // General

    // 

    // Action : Test to turn camera power off two time, when initialization is done.

	//      

	// Output : OK.   

    iStatesClient->RunTestActionL( CCaeTestStatesClient::EPowerOffPowerOff );

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

    }

void CCaeTestStillStates::TestCaptureAfterPowerOffOnL()

    {

	// ID: CAE.SC.CAPTURESTILL.POWEROFF.002

    //

    // Group:   Capture

    // 

    // Action : Test to prepare still capturing and capture Vga Exif image 

    //          image after poweroff + poweron.

	//      

	// Output : No leave, image cae_snap_1_8_vga_poweroffon captured

    TSize sizeVga( KImgWidthVGA, KImgHeightVGA );

    iStatesClient->SetStillFrameSize( sizeVga );

    iStatesClient->SetStillFormat( CCamera::EFormatExif );

    //iStatesClient->SetSnapFileName( _L("cae_snap_1_8_vga_poweroff.mbm") );

    iStatesClient->SetSnapImageSize( TSize( 44, 52 ) );

    iStatesClient->SetStillFileName( _L("cae_snap_1_8_vga_poweroffon.jpg") );

    iStatesClient->RunTestActionL( CCaeTestStatesClient::ECaptureStillAfterPowerOffOn );

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

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

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

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

    }

void CCaeTestStillStates::TestStartVfStartVfL()

    {

	// CAE.VF.STARTVIEWFINDERSTARTVIEWFINDER.001

    //

    // View Finder

    // 

    // Action : Test start two time view finder, when initialization is done.

	//      

	// Output : OK.   

    TSize sizeQqvga( KImgWidthQQVGA, KImgHeightQQVGA );

    iStatesClient->SetViewFinderSize( sizeQqvga );

    iStatesClient->SetTimeout( 100000 );

    iStatesClient->RunTestActionL( CCaeTestStatesClient::EStartVfStartVf );

    }

void CCaeTestStillStates::TestStartVfWhenPowerOffL()

    {

	// CAE.VF.STARTVIEWFINDERWHENPOWEROFF.001

    //

    // View Finder

    // 

    // Action : Test to start view finder when power is off, initialization is done.

	//      

	// Output : Leave.  

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

    assertL( error == KErrNotReady );

    }

void CCaeTestStillStates::TestCancelCaptureStillWhenInitializedL()

    {

	// CAE.SC.CANCEL.001

    //

    // Capture (actually just cancelling)

    // 

    // Action : Test to cancel still capturing when just initialization is done.

	//      

	// Output : OK.  

    iStatesClient->RunTestActionL( CCaeTestStatesClient::ECancelCaptureStillWhenInitialized );

    }

void CCaeTestStillStates::TestCancelCaptureStillAtSnapL()

    {

	// CAE.SC.CANCEL.002

    //

    // Capture

    // 

    // Action : Test to cancel still capturing after snap image callback. Captures an image after cancelling.

	//      

	// Output : OK.  

    iStatesClient->SetStillQualityLevelIndex( 0 );

    iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareAndCaptureAndCancelStillAtSnap );

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

    assertL( iStatesClient->CountStillPrepareComplete() == 2 ); // == 2 because calling PrepareStillCaptureL after cancelling

    assertL( iStatesClient->CountSnapImageReady() == 3 );

    // Changed this from 2 to 3. Before it was timing dependent, giving either value. Now the case is timed better.

    assertL( iStatesClient->CountStillImageReady() == 3 ); 

    }

/********************************************************/

/*                STILL BURST TESTS                     */

/********************************************************/

void CCaeTestStillStates::TestCaptureCaptureStillBurst3L()

    {

	// ID: CAE.SC.CAPTURECAPTURESTILLBURST.3.001

    //

    // Group:   Capture

    // 

    // Action : Test to prepare still capturing burst mode and capture three  

    //          images in a burst when initialization is done. Then repeat the burst capture.

	//      

	// Output : OK.   

    const TInt KStillBurstLength = 3;

    iStatesClient->SetStillQualityLevelIndex( 0 );

    iStatesClient->SetSnapFileName( _L("cae_snap_vga16M_burstburst3.mbm") );

    iStatesClient->SetStillFileName( _L("cae_vga16M_burstburst3.jpg") );

    iStatesClient->SetStillBurstLength( KStillBurstLength );

    iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareAndCaptureCaptureStillBurst );

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

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

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

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

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

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

    }

void CCaeTestStillStates::TestSpecPrepCaptureCaptureStillBurst3L()

    {

	// ID: CAE.SC.CAPTURECAPTURESTILLBURST.3.002

    //

    // Group:   Capture

    // 

    // Action : Test to prepare still capturing burst mode and capture three  

    //          images in a burst when initialization is done. Then repeat the burst capture.

	//      

	// Output : OK.   

    const TInt KStillBurstLength = 3;

    iStatesClient->SetStillFormat( CCamera::EFormatFbsBitmapColor16M );

    TSize sizevga( KImgWidthVGA, KImgHeightVGA );

    iStatesClient->SetStillFrameSize( sizevga );

    iStatesClient->SetSnapFileName( _L("cae_snap_vga16M_spburstburst3.mbm") );

    iStatesClient->SetStillFileName( _L("cae_vga16M_spburstburst3.mbm") );

    iStatesClient->SetStillBurstLength( KStillBurstLength );

    iStatesClient->RunTestActionL( CCaeTestStatesClient::ESpecPrepAndCaptureCaptureStillBurst );

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

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

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

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

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

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

    }

void CCaeTestStillStates::TestCaptureStillBurst3CaptureStillL()

    {

	// ID: CAE.SC.CAPTURESTILLBURSTCAPTURESTILL.3.001

    //

    // Group:   Capture

    // 

    // Action : Test to prepare still capturing burst mode and capture three  

    //          images in a burst when initialization is done. Then repeat the burst capture.

	//      

	// Output : OK.   

    const TInt KStillBurstLength = 3;

    iStatesClient->SetStillQualityLevelIndex( 0 );

    iStatesClient->SetSnapFileName( _L("cae_snap_vga16M_burst3capture.mbm") );

    iStatesClient->SetStillFileName( _L("cae_vga16M_burst3capture.jpg") );

    iStatesClient->SetStillBurstLength( KStillBurstLength );

    iStatesClient->RunTestActionL( CCaeTestStatesClient::EPrepareAndCaptureStillBurstCaptureStill );

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

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

    assertL( iStatesClient->CountStillBurstCaptureMoment() == KStillBurstLength );

    assertL( iStatesClient->CountSnapImageReady() == ( KStillBurstLength + 1 ) );

    assertL( iStatesClient->CountStillImageReady() == ( KStillBurstLength + 1 ) );

    assertL( iStatesClient->CountStillBurstComplete() == 1 );

    }

void CCaeTestStillStates::TestSpecPrepCaptureStillBurst3CaptureStillL()

    {

	// ID: CAE.SC.CAPTURESTILLBURSTCAPTURESTILL.3.002

    //

    // Group:   Capture

    // 

    // Action : Test to prepare still capturing burst mode and capture three  

    //          images in a burst when initialization is done. Then repeat the burst capture.

	//      

	// Output : OK.   

    const TInt KStillBurstLength = 3;

    iStatesClient->SetStillFormat( CCamera::EFormatFbsBitmapColor16M );

    TSize sizevga( KImgWidthVGA, KImgHeightVGA );

    iStatesClient->SetStillFrameSize( sizevga );

    iStatesClient->SetSnapFileName( _L("cae_snap_qqvga16M_spburst3capture.mbm") );

    iStatesClient->SetStillFileName( _L("cae_qqvga16M_spburst3capture.mbm") );

    iStatesClient->SetStillBurstLength( KStillBurstLength );