/**

* Copyright (c) 2010 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:   tester for methods in TestVolumeControl

*

*/

// Version : %version:  1 %

#include <qdebug>

#include <QTimer>

#include <hbmainwindow.h>

#include <hbapplication.h>

#include <qgraphicssceneevent>

#include <hbvolumesliderpopup.h>

#include "testvolumecontrol.h"

#include "videoplaybackviewfiledetails.h"

#include "videoplaybackcontrolscontroller.h"

#define private public

#include "videoplaybackvolumecontrol.h"

#undef private

// -------------------------------------------------------------------------------------------------

// main

// -------------------------------------------------------------------------------------------------

//

int main(int argc, char *argv[])

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::Main()"));

    HbApplication app(argc, argv);

    HbMainWindow window;

    TestVolumeControl tv;

    char *pass[3];

    pass[0] = argv[0];

    pass[1] = "-o";

    pass[2] = "c:\\data\\testvolumecontrol.txt";

    int res = QTest::qExec(&tv, 3, pass);

    return res;

}

// -------------------------------------------------------------------------------------------------

// init

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::init()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::init()"));

    mController = new VideoPlaybackControlsController();

    mVolumeControl = new VideoPlaybackVolumeControl( mController );

}

// -------------------------------------------------------------------------------------------------

// init

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::setup()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::init()"));

    init();

    mController->mVolumeSteps = 10;

    mController->fileDetails()->mAudioEnabled = true;

    mVolumeControl->setVisible( true );

}

// -------------------------------------------------------------------------------------------------

// cleanup

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::cleanup()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::cleanup()"));

    if ( mController )

    {

        delete mController;

        mController = NULL;

    }

    if ( mVolumeControl )

    {

        delete mVolumeControl;

        mVolumeControl = NULL;

    }

}

// -------------------------------------------------------------------------------------------------

// testVolumeChanged

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::testVolumeChanged()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::testVolumeChanged()"));

    setup();

    int changedVolume = 3;

    int currentVolume = 5;

    mVolumeControl->mVolume = 5;

    //

    // If mExpectedVolList is not empty

    //

    mVolumeControl->mExpectedVolList.append( changedVolume );

    mVolumeControl->volumeChanged( changedVolume );

    QVERIFY( mVolumeControl->mVolume == currentVolume );

    //

    // If mExpectedVolList is empty

    //

    mVolumeControl->mExpectedVolList.clear();

    //

    // If user is dragging the thumb, we don't update volume

    //

    mVolumeControl->mDragging = true;

    mVolumeControl->volumeChanged( changedVolume );

    QVERIFY( mVolumeControl->mVolume == currentVolume );

    QVERIFY( mVolumeControl->mVolumePopup->isVisible() );

    //

    // If user isn't dragging the thumb, we update volume

    //

    mVolumeControl->mDragging = false;

    mVolumeControl->volumeChanged( changedVolume );

    QVERIFY( mVolumeControl->mVolume == changedVolume );

    QVERIFY( mVolumeControl->mVolumePopup->isVisible() );

    cleanup();

}

// -------------------------------------------------------------------------------------------------

// testSetVisible

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::testSetVisible()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::testSetVisible()"));

    init();

    //

    // Audio + video clip

    //

    mController->mVolumeSteps = 30;

    mController->fileDetails()->mAudioEnabled = true;

    bool visible = true;

    mVolumeControl->setVisible( visible );

    QVERIFY( mVolumeControl->mVolumePopup->isVisible() == visible );

    QVERIFY( mVolumeControl->mVolumePopup->mMin == 0 );

    QVERIFY( mVolumeControl->mVolumePopup->mMax ==  mController->mVolumeSteps );

    QVERIFY( mVolumeControl->mDraggingHandlerTimer );

    cleanup();

    //

    // Audio only

    //

    init();

    mController->fileDetails()->mAudioEnabled = false;

    mVolumeControl->setVisible( visible );

    QVERIFY( mVolumeControl->mVolumePopup->isVisible() == visible );

    QVERIFY( ! mVolumeControl->mVolumePopup->isEnabled() );

    QVERIFY( ! mVolumeControl->mDraggingHandlerTimer );

    cleanup();

}

// -------------------------------------------------------------------------------------------------

// testIsVisible

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::testIsVisible()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::testIsVisible()"));

    setup();

    bool visible = true;

    mVolumeControl->mVolumePopup->mVisible = visible;

    QVERIFY( mVolumeControl->mVolumePopup->isVisible() == visible );

    cleanup();

}

// -------------------------------------------------------------------------------------------------

// testHandleSliderValueChanged

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::testHandleSliderValueChanged()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::testHandleSliderValueChanged()"));

    setup();

    int changedValue = 3;

    mVolumeControl->mVolume = 5;

    connect( this, SIGNAL( commandSignal( int ) ), mVolumeControl, SLOT( handleSliderValueChanged( int ) ) );

    //

    // If mDragging is ture

    //

    mVolumeControl->mDragging = true;

    emit commandSignal( changedValue );

    QVERIFY( mVolumeControl->mDraggingVolume == changedValue * mVolumeControl->mVolumeNormalizer );

    //

    // If mDragging is false

    //

    mVolumeControl->mDragging = false;

    emit commandSignal( changedValue );

    QVERIFY( mVolumeControl->mVolume == changedValue * mVolumeControl->mVolumeNormalizer );

    QVERIFY( mController->mCommand == EMPXPbvCmdSetVolume );

    QVERIFY( mController->mValue == changedValue * mVolumeControl->mVolumeNormalizer );

    disconnect( this, SIGNAL( commandSignal( int ) ), mVolumeControl, SLOT( handleSliderValueChanged( int ) ) );

    cleanup();

}

// -------------------------------------------------------------------------------------------------

// testHandleMuteIconClicked

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::testHandleMuteIconClicked()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::testHandleMuteIconClicked()"));

    setup();

    connect( this, SIGNAL( commandSignal() ), mVolumeControl, SLOT( handleMuteIconClicked() ) );

    //

    // mVolumePopup->value() is not 0

    //

    mVolumeControl->mVolumePopup->mValue = 5;

    emit commandSignal();

    QVERIFY( mController->mCommand == EMPXPbvCmdUnMute );

    //

    // mVolumePopup->value() is 0

    //

    mVolumeControl->mVolumePopup->mValue = 0;

    mVolumeControl->mMutedByMuteIcon = false;

    emit commandSignal();

    QVERIFY( mVolumeControl->mMutedByMuteIcon );

    QVERIFY( mController->mCommand == EMPXPbvCmdMute );

    disconnect( this, SIGNAL( commandSignal() ), mVolumeControl, SLOT( handleMuteIconClicked() ) );

    cleanup();

}

// -------------------------------------------------------------------------------------------------

// testHandleSliderPressed

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::testHandleSliderPressed()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::testHandleSliderPressed()"));

    setup();

    connect( this, SIGNAL( commandSignal() ), mVolumeControl, SLOT( handleSliderPressed() ) );

    mVolumeControl->mDragging = false;

    mVolumeControl->mDraggingHandlerTimer->start();

    emit commandSignal();

    QVERIFY( mVolumeControl->mDragging );

    QVERIFY( mVolumeControl->mDraggingHandlerTimer->isActive() );

    disconnect( this, SIGNAL( commandSignal() ), mVolumeControl, SLOT( handleSliderPressed() ) );

    cleanup();

}

// -------------------------------------------------------------------------------------------------

// testHandleSliderReleased

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::testHandleSliderReleased()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::testHandleSliderReleased()"));

    setup();

    connect( this, SIGNAL( commandSignal() ), mVolumeControl, SLOT( handleSliderReleased() ) );

    mVolumeControl->mDragging = true;

    mVolumeControl->mDraggingVolume = 3;

    mVolumeControl->mVolume = 5;

    emit commandSignal();

    QVERIFY( ! mVolumeControl->mDragging );

    QVERIFY( ! mVolumeControl->mDraggingHandlerTimer->isActive() );

    QVERIFY( mVolumeControl->mVolume == mVolumeControl->mDraggingVolume );

    QVERIFY( mController->mCommand == EMPXPbvCmdSetVolume );

    QVERIFY( mController->mValue == mVolumeControl->mDraggingVolume );

    disconnect( this, SIGNAL( commandSignal() ), mVolumeControl, SLOT( handleSliderReleased() ) );

    cleanup();

}

// -------------------------------------------------------------------------------------------------

// testHandleDraggingTimerTimeOut

// -------------------------------------------------------------------------------------------------

//

void TestVolumeControl::testHandleDraggingTimerTimeOut()

{

    MPX_ENTER_EXIT(_L("TestVolumeControl::testHandleDraggingTimerTimeOut()"));

    setup();

    connect( this, SIGNAL( commandSignal() ), mVolumeControl, SLOT( handleDraggingTimerTimeOut() ) );

    //

    // mDragging is false

    //

    mVolumeControl->mDragging = false;

    mVolumeControl->mVolume = 6;

    mVolumeControl->mDraggingVolume = 10;

    emit commandSignal();

    QVERIFY( mVolumeControl->mVolume != mVolumeControl->mDraggingVolume );

    //

    // mDragging is true

    //

    mVolumeControl->mDragging = true;

    emit commandSignal();

    QVERIFY( mVolumeControl->mVolume == mVolumeControl->mDraggingVolume );

    QVERIFY( mController->mCommand == EMPXPbvCmdSetVolume );

    QVERIFY( mController->mValue == mVolumeControl->mVolume );

    //

    // mDragging is true && vol == 0 && mMutedByMuteIcon is true

    //

    mVolumeControl->mDragging = true;

    mVolumeControl->mDraggingVolume = 0;

    mVolumeControl->mMutedByMuteIcon = true;

    emit commandSignal();

    QVERIFY( ! mVolumeControl->mMutedByMuteIcon );

    disconnect( this, SIGNAL( commandSignal() ), mVolumeControl, SLOT( handleDraggingTimerTimeOut() ) );

    cleanup();

}

// End of file