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: Unit test for mpvolumeslider

    15 *

    16 */

    17 

    18 #include <QMetaType>

    19 

    20 #include "stub/inc/mpenginefactory.h"

    21 #include "stub/inc/hbvolumesliderpopup.h"

    22 #include "unittest_mpvolumeslider.h"

    23 

    24 

    25 // Do this so we can access all member variables.

    26 #define private public

    27 #include "mpvolumeslider.h"

    28 #undef private

    29 

    30 // Do this so private function can be accessed

    31 #include <../../src/mpvolumeslider.cpp>

    32 

    33 /*!

    34  Make our test case a stand-alone executable that runs all the test functions.

    35  */

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

    37 {

    38     QApplication app(argc, argv);

    39 

    40     TestMpVolumeSlider tv;

    41 

    42     if ( argc > 1 ) {

    43         return QTest::qExec( &tv, argc, argv);

    44     }

    45     else {

    46         char *pass[3];

    47         pass[0] = argv[0];

    48         pass[1] = "-o";

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

    50 

    51         return QTest::qExec(&tv, 3, pass);

    52     }

    53 }

    54 

    55 TestMpVolumeSlider::TestMpVolumeSlider()

    56     : mTest(0)

    57 {

    58 }

    59 

    60 TestMpVolumeSlider::~TestMpVolumeSlider()

    61 {

    62     delete mTest;

    63 }

    64 

    65 /*!

    66  Called before the first testfunction is executed.

    67  */

    68 void TestMpVolumeSlider::initTestCase()

    69 {

    70 }

    71 

    72 /*!

    73  Called after the last testfunction was executed.

    74  */

    75 void TestMpVolumeSlider::cleanupTestCase()

    76 {

    77 }

    78 

    79 /*!

    80  Called before each testfunction is executed.

    81  */

    82 void TestMpVolumeSlider::init()

    83 {

    84     mTest = new MpVolumeSlider();

    85 }

    86 

    87 /*!

    88  Called after every testfunction.

    89  */

    90 void TestMpVolumeSlider::cleanup()

    91 {

    92     if (mTest)

    93     {

    94         delete mTest;

    95         mTest = 0;

    96 

    97         MpEngineFactory::close();

    98     }

    99 }

   100 

   101 void TestMpVolumeSlider::testConstructor()

   102 {

   103     QVERIFY( mTest );

   104     QCOMPARE(mTest->mMpEngine->iMediaPropertyRequested.value(0), PropVolumeLevelMax);

   105     QCOMPARE(mTest->mMpEngine->iMediaPropertyRequested.value(1), PropVolumeLevel);

   106     QCOMPARE(mTest->mMpEngine->iMediaPropertyRequested.value(2), PropVolumeMuteState);

   107 }

   108 

   109 void TestMpVolumeSlider::testShowVolumeSlider()

   110 {

   111     mTest->mEngineVolumeMax = 100;

   112     mTest->mEngineMuted = true;

   113     mTest->mEngineVolumeLevel = 30;

   114 

   115     // While VolumeSlider is pressed showVolumeSlider() function does nothing.

   116     mTest->mSliderPressed = true;

   117     mTest->showVolumeSlider();

   118     QVERIFY( !mTest->mVolumeSliderPopup );

   119 

   120     // When VolumeSlider is not being pressed, showVolumeSlider() attempts to show the slider.

   121     mTest->mSliderPressed = false;

   122     mTest->showVolumeSlider();

   123     QVERIFY( mTest->mVolumeSliderPopup );

   124     QCOMPARE( mTest->mVolumeSliderPopup->mValue, 0 );    //Currently in mute state

   125     QVERIFY( mTest->mVolumeSliderPopup->isVisible() );

   126 

   127     // Clearing mute state

   128     mTest->mEngineMuted = false;

   129     mTest->showVolumeSlider();

   130     QVERIFY( mTest->mVolumeSliderPopup );

   131     QCOMPARE( mTest->mVolumeSliderPopup->mValue, 3 );

   132     QVERIFY( mTest->mVolumeSliderPopup->isVisible() );

   133 }

   134 

   135 void TestMpVolumeSlider::testHandleVolumeProperty()

   136 {

   137     MpEngine *mpEngineInstance = MpEngineFactory::sharedEngine();

   138     connect( this, SIGNAL(triggerVolumePropertyChanged( MpCommon::MpVolumeProperty, int ) ),

   139              mpEngineInstance, SIGNAL( volumePropertyChanged( MpCommon::MpVolumeProperty, int ) ) );

   140     

   141     emit triggerVolumePropertyChanged( MpCommon::MaxVolume, 100 );

   142     QCOMPARE( mTest->mEngineDataCompleted, 0x01 );

   143     QCOMPARE( mTest->mEngineVolumeMax, 100 );

   144     QVERIFY( !mTest->mVolumeSliderPopup );

   145 

   146     emit triggerVolumePropertyChanged( MpCommon::Volume, 0 );

   147     QCOMPARE( mTest->mEngineDataCompleted, 0x03 );

   148     QCOMPARE( mTest->mEngineVolumeLevel, 0 );

   149     QVERIFY( mTest->mEngineMuted );

   150     QVERIFY( !mTest->mVolumeSliderPopup );

   151     emit triggerVolumePropertyChanged( MpCommon::Volume, 30 );

   152     QCOMPARE( mTest->mEngineDataCompleted, 0x03 );

   153     QCOMPARE( mTest->mEngineVolumeLevel, 30 );

   154     QVERIFY( !mTest->mEngineMuted );

   155     QVERIFY( !mTest->mVolumeSliderPopup );

   156     mTest->mEngineDataCompleted = 0x07;

   157     emit triggerVolumePropertyChanged( MpCommon::Volume, 40 );

   158     QCOMPARE( mTest->mEngineDataCompleted, 0x07 );

   159     QCOMPARE( mTest->mEngineVolumeLevel, 40 );

   160     QVERIFY( !mTest->mEngineMuted );

   161     QVERIFY( mTest->mVolumeSliderPopup->isVisible() );

   162 

   163     mTest->mEngineDataCompleted = 0x03;

   164     mTest->mVolumeSliderPopup->setVisible( false );

   165     emit triggerVolumePropertyChanged( MpCommon::MuteState, 1 );

   166     QCOMPARE( mTest->mEngineDataCompleted, 0x07 );

   167     QVERIFY( mTest->mEngineMuted );

   168     QVERIFY( !mTest->mVolumeSliderPopup->isVisible() );

   169     emit triggerVolumePropertyChanged( MpCommon::MuteState, 0 );

   170     QCOMPARE( mTest->mEngineDataCompleted, 0x07 );

   171     QVERIFY( !mTest->mEngineMuted );

   172     QVERIFY( mTest->mVolumeSliderPopup->isVisible() );

   173 }

   174 

   175 void TestMpVolumeSlider::testSliderPressed()

   176 {

   177     mTest->mEngineMuted = false;

   178     mTest->mEngineVolumeLevel = 20;

   179     mTest->mEngineVolumeMax = 100;

   180     mTest->initializeVolumeSliderPopup();

   181     connect( this, SIGNAL( triggerSliderPressed() ), 

   182              mTest->mVolumeSliderPopup, SIGNAL( sliderPressed() ) );

   183 

   184     emit triggerSliderPressed();

   185     QVERIFY( mTest->mSliderPressed );

   186 }

   187 

   188 void TestMpVolumeSlider::testSliderReleased()

   189 {

   190     mTest->mEngineMuted = false;

   191     mTest->mEngineVolumeLevel = 20;

   192     mTest->mEngineVolumeMax = 100;

   193     mTest->initializeVolumeSliderPopup();

   194     connect( this, SIGNAL( triggerSliderReleased() ), 

   195              mTest->mVolumeSliderPopup, SIGNAL( sliderReleased() ) );

   196     mTest->mSliderPressed = true;

   197 

   198     emit triggerSliderReleased();

   199     QVERIFY( !mTest->mSliderPressed );

   200 }

   201 

   202 void TestMpVolumeSlider::testMuteIconClicked()

   203 {

   204     mTest->mEngineMuted = false;

   205     mTest->mEngineVolumeLevel = 20;

   206     mTest->mEngineVolumeMax = 100;

   207     mTest->initializeVolumeSliderPopup();

   208     connect( this, SIGNAL( triggerIconClicked() ), 

   209              mTest->mVolumeSliderPopup, SIGNAL( iconClicked() ) );

   210 

   211     mTest->mVolumeSliderPopup->setValue( 0 );

   212     emit triggerIconClicked();

   213     QCOMPARE( mTest->mMpEngine->iMediaCommandReceived, CmdMuteVolume );

   214     QVERIFY( mTest->mEngineMuted );

   215 

   216     mTest->mVolumeSliderPopup->setValue( 1 );

   217     emit triggerIconClicked();

   218     QCOMPARE( mTest->mMpEngine->iMediaCommandReceived, CmdUnmuteVolume );

   219     QVERIFY( !mTest->mEngineMuted );

   220 }

   221 

   222 void TestMpVolumeSlider::testVolumeSliderChanged()

   223 {

   224     mTest->mEngineMuted = false;

   225     mTest->mEngineVolumeLevel = 20;

   226     mTest->mEngineVolumeMax = 100;

   227     mTest->initializeVolumeSliderPopup();

   228     connect( this, SIGNAL( triggerValueChanged( int ) ), 

   229              mTest->mVolumeSliderPopup, SIGNAL( valueChanged( int ) ) );

   230 

   231     mTest->mEngineVolumeLevel = 60;

   232     mTest->mEngineMuted = false;

   233     // Same values slider and engine

   234     emit triggerValueChanged( 6 );

   235     QTest::qWait(25);

   236     QCOMPARE( mTest->mMpEngine->iMediaCommandReceived, CmdNone );

   237     QCOMPARE( mTest->mMpEngine->iCommandValue, -1 );

   238     // Slider value smaller than engine

   239     mTest->mMpEngine->iMediaCommandReceived = CmdNone;

   240     mTest->mMpEngine->iCommandValue = -1;

   241     emit triggerValueChanged( 0 );

   242     QTest::qWait(25);

   243     QCOMPARE( mTest->mMpEngine->iMediaCommandReceived, CmdSetVolumeLevel );

   244     QCOMPARE( mTest->mMpEngine->iCommandValue, 0 );

   245     // Slider value bigger than engine

   246     mTest->mMpEngine->iMediaCommandReceived = CmdNone;

   247     mTest->mMpEngine->iCommandValue = -1;

   248     emit triggerValueChanged( 7 );

   249     QTest::qWait(25);

   250     QCOMPARE( mTest->mMpEngine->iMediaCommandReceived, CmdSetVolumeLevel );

   251     QCOMPARE( mTest->mMpEngine->iCommandValue, 70 );

   252 

   253     mTest->mEngineMuted = true;

   254     // Slider changes to 0 while engine in mute state.

   255     mTest->mMpEngine->iMediaCommandReceived = CmdNone;

   256     mTest->mMpEngine->iCommandValue = -1;

   257     emit triggerValueChanged( 0 );

   258     QTest::qWait(25);

   259     QCOMPARE( mTest->mMpEngine->iMediaCommandReceived, CmdNone );

   260     QCOMPARE( mTest->mMpEngine->iCommandValue, -1 );

   261     // Slider changes other than 0 while engine in mute state.

   262     mTest->mMpEngine->iMediaCommandReceived = CmdNone;

   263     mTest->mMpEngine->iCommandValue = -1;

   264     emit triggerValueChanged( 8 );

   265     QTest::qWait(25);

   266     QCOMPARE( mTest->mMpEngine->iMediaCommandReceived, CmdSetVolumeLevel );

   267     QCOMPARE( mTest->mMpEngine->iCommandValue, 80 );

   268 }

   269 

   270 void TestMpVolumeSlider::testInitializeVolumeSliderPopup()

   271 {

   272     mTest->mEngineMuted = false;

   273     mTest->mEngineVolumeLevel = 20;

   274     mTest->mEngineVolumeMax = 100;

   275 

   276     mTest->initializeVolumeSliderPopup();

   277     QVERIFY( mTest->mVolumeSliderPopup );

   278     QCOMPARE( mTest->mVolumeSliderPopup->mMinRange, 0 );

   279     QCOMPARE( mTest->mVolumeSliderPopup->mMaxRange, 10 );

   280     QCOMPARE( mTest->mVolumeSliderPopup->mSingleStep, 1 );

   281     QCOMPARE( mTest->mVolumeSliderPopup->mSliderTickPosition, Hb::NoSliderTicks );

   282     QCOMPARE( mTest->mSliderStep, 10 );

   283 }

   284 

   285 

   286 // End of file