1 /**

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

    15 *

    16 */

    17 

    18 // Version : %version:  6 %

    19 

    20 

    21 #include <qdebug>

    22 #include <hbmainwindow.h>

    23 #include <hbapplication.h>

    24 #include <qgraphicssceneevent>

    25 #include <hbprogressslider.h>

    26 

    27 

    28 #include "testprogressbar.h"

    29 #include "mpxvideoplaybackviewfiledetails.h"

    30 #include "mpxvideoplaybackcontrolscontroller.h"

    31 

    32 #define private public

    33 #include "mpxvideoplaybackprogressbar.h"

    34 #undef private

    35 

    36 // -------------------------------------------------------------------------------------------------

    37 // main

    38 // -------------------------------------------------------------------------------------------------

    39 //

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

    41 {

    42     MPX_ENTER_EXIT(_L("TestProgressBar::Main()"));

    43 

    44     HbApplication app(argc, argv);

    45     HbMainWindow window;

    46 

    47     TestProgressBar tv;

    48 

    49     char *pass[3];

    50     pass[0] = argv[0];

    51     pass[1] = "-o";

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

    53 

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

    55 

    56     return res;

    57 }

    58 

    59 

    60 // -------------------------------------------------------------------------------------------------

    61 // init

    62 // -------------------------------------------------------------------------------------------------

    63 //

    64 void TestProgressBar::init()

    65 {

    66     MPX_ENTER_EXIT(_L("TestProgressBar::init()"));

    67 }

    68 

    69 // -------------------------------------------------------------------------------------------------

    70 // setup

    71 // -------------------------------------------------------------------------------------------------

    72 //

    73 void TestProgressBar::setup()

    74 {

    75     MPX_ENTER_EXIT(_L("TestProgressBar::setup()"));

    76 

    77     mController = new QMPXVideoPlaybackControlsController();

    78     mProgBar = new QMPXVideoPlaybackProgressBar( mController );

    79 

    80     mProgBar->initialize();

    81 }

    82 

    83 // -------------------------------------------------------------------------------------------------

    84 // cleanup

    85 // -------------------------------------------------------------------------------------------------

    86 //

    87 void TestProgressBar::cleanup()

    88 {

    89     MPX_ENTER_EXIT(_L("TestProgressBar::cleanup()"));

    90 

    91     if ( mController )

    92     {

    93         delete mController;

    94         mController = NULL;

    95     }

    96 

    97     if ( mProgBar )

    98     {

    99         delete mProgBar;

   100         mProgBar = NULL;

   101     }

   102 }

   103 

   104 // -------------------------------------------------------------------------------------------------

   105 // testHandleSliderPressed

   106 // -------------------------------------------------------------------------------------------------

   107 //

   108 void TestProgressBar::testHandleSliderPressed()

   109 {

   110     MPX_ENTER_EXIT(_L("TestProgressBar::testHandleSliderPressed()"));

   111 

   112     setup();

   113 

   114     //

   115     // If it is playing state

   116     //

   117     mController->mState = EPbStatePlaying;

   118 

   119     emit mProgBar->mProgressSlider->press();

   120 

   121     QVERIFY( mController->mTimerAction == EMPXTimerCancel );

   122     QVERIFY( mController->mCommand == EMPXPbvCmdCustomPause );

   123     QVERIFY( mProgBar->mSliderDragging );

   124     QVERIFY( mProgBar->mNeedToResumeAfterSetPosition );

   125 

   126     //

   127     // If it is pause state

   128     //

   129     mController->mState = EPbStatePaused;

   130     mController->mCommand = EMPXPbvCmdStop;

   131 

   132     emit mProgBar->mProgressSlider->press();

   133 

   134     QVERIFY( mController->mTimerAction == EMPXTimerCancel );

   135     QVERIFY( mController->mCommand == EMPXPbvCmdStop );

   136     QVERIFY( mProgBar->mSliderDragging );

   137     QVERIFY( mProgBar->mNeedToResumeAfterSetPosition );

   138 

   139     cleanup();

   140 }

   141 

   142 // -------------------------------------------------------------------------------------------------

   143 // testHandleSliderReleased

   144 // -------------------------------------------------------------------------------------------------

   145 //

   146 void TestProgressBar::testHandleSliderReleased()

   147 {

   148     MPX_ENTER_EXIT(_L("TestProgressBar::testHandleSliderReleased()"));

   149 

   150     setup();

   151 

   152     //

   153     // Moved position >= duration

   154     //

   155     mProgBar->mDuration = 120;

   156     mProgBar->mProgressSlider->mSliderValue = 130;

   157     mController->mTimerAction = EMPXTimerCancel;

   158     mController->mCommand = EMPXPbvCmdStop;

   159 

   160     emit mProgBar->mProgressSlider->release();

   161     QVERIFY( mController->mTimerAction == EMPXTimerReset );

   162     QVERIFY( ! mProgBar->mSliderDragging );

   163     QVERIFY( mController->mCommand == EMPXPbvCmdEndOfClip );

   164 

   165     //

   166     // Moved position < 0

   167     //

   168     mProgBar->mProgressSlider->mSliderValue = -1;

   169     mController->mTimerAction = EMPXTimerCancel;

   170     mController->mCommand = EMPXPbvCmdStop;

   171     mController->mValue = 100;

   172 

   173     emit mProgBar->mProgressSlider->release();

   174     QVERIFY( mController->mTimerAction == EMPXTimerReset );

   175     QVERIFY( ! mProgBar->mSliderDragging );

   176     QVERIFY( mController->mCommand == EMPXPbvCmdSetPosition );

   177     QVERIFY( mController->mValue == 0 );

   178 

   179     //

   180     // 0 <= moved position < duration

   181     //

   182     mProgBar->mProgressSlider->mSliderValue = 60;

   183     mController->mTimerAction = EMPXTimerCancel;

   184     mController->mCommand = EMPXPbvCmdStop;

   185 

   186     emit mProgBar->mProgressSlider->release();

   187     QVERIFY( mController->mTimerAction == EMPXTimerReset );

   188     QVERIFY( ! mProgBar->mSliderDragging );

   189     QVERIFY( mController->mCommand == EMPXPbvCmdSetPosition );

   190     QVERIFY( mController->mValue == mProgBar->mProgressSlider->mSliderValue );

   191 

   192     cleanup();

   193 }

   194 

   195 // -------------------------------------------------------------------------------------------------

   196 // testHandleSliderMoved

   197 // -------------------------------------------------------------------------------------------------

   198 //

   199 void TestProgressBar::testHandleSliderMoved()

   200 {

   201     MPX_ENTER_EXIT(_L("TestProgressBar::testHandleSliderMoved()"));

   202 

   203     setup();

   204 

   205     //

   206     // If user is dragging the slider

   207     //

   208     int movedPositoin = 5;

   209     mProgBar->mDuration = 20;

   210     mProgBar->mSliderDragging = true;

   211     emit mProgBar->mProgressSlider->move( movedPositoin );

   212 

   213     QVERIFY( mProgBar->mDraggingPosition == movedPositoin );

   214     QVERIFY( mProgBar->mProgressSlider->progressValue() == movedPositoin );

   215     QVERIFY( mProgBar->mProgressSlider->sliderValue() == movedPositoin );

   216 

   217     //

   218     // If user isnot dragging the slider and movedPosition > mDuration

   219     //

   220     movedPositoin = 30;

   221     mProgBar->mSliderDragging = false;

   222 

   223     emit mProgBar->mProgressSlider->move( movedPositoin );

   224 

   225     QVERIFY( mProgBar->mProgressSlider->progressValue() == mProgBar->mDuration );

   226     QVERIFY( mProgBar->mProgressSlider->sliderValue() == mProgBar->mDuration );

   227     QVERIFY( mController->mCommand == EMPXPbvCmdEndOfClip );

   228 

   229     //

   230     // If user isnot dragging the slider and movedPosition < mDuration

   231     //

   232     movedPositoin = 10;

   233 

   234     emit mProgBar->mProgressSlider->move( movedPositoin );

   235 

   236     QVERIFY( mProgBar->mProgressSlider->progressValue() == movedPositoin );

   237     QVERIFY( mProgBar->mProgressSlider->sliderValue() == movedPositoin );

   238 

   239     QVERIFY( mController->mCommand == EMPXPbvCmdSetPosition );

   240     QVERIFY( mController->mValue == movedPositoin );

   241 

   242     cleanup();

   243 }

   244 

   245 // -------------------------------------------------------------------------------------------------

   246 // testUpdateWithFileDetails

   247 // -------------------------------------------------------------------------------------------------

   248 //

   249 void TestProgressBar::testUpdateWithFileDetails()

   250 {

   251     MPX_ENTER_EXIT(_L("TestProgressBar::testUpdateWithFileDetails()"));

   252 

   253     setup();

   254 

   255     //

   256     // pausable + non seekable

   257     //

   258     mController->mFileDetails->mPausableStream = true;

   259     mController->mFileDetails->mSeekable = false;

   260     mProgBar->updateWithFileDetails( mController->mFileDetails );

   261     QVERIFY( ! mProgBar->mProgressSlider->isEnabled() );

   262 

   263     //

   264     // non pausable + seekable

   265     //

   266     mController->mFileDetails->mPausableStream = false;

   267     mController->mFileDetails->mSeekable = true;

   268     mProgBar->updateWithFileDetails( mController->mFileDetails );

   269     QVERIFY( ! mProgBar->mProgressSlider->isEnabled() );

   270 

   271     //

   272     // non pausable + non seekable

   273     //

   274     mController->mFileDetails->mPausableStream = false;

   275     mController->mFileDetails->mSeekable = false;

   276     mProgBar->updateWithFileDetails( mController->mFileDetails );

   277     QVERIFY( ! mProgBar->mProgressSlider->isEnabled() );

   278 

   279     //

   280     // other cases

   281     //

   282     mController->mFileDetails->mPausableStream = true;

   283     mController->mFileDetails->mSeekable = true;

   284     mProgBar->updateWithFileDetails( mController->mFileDetails );

   285     QVERIFY( mProgBar->mProgressSlider->isEnabled() );

   286 

   287     cleanup();

   288 }

   289 

   290 // -------------------------------------------------------------------------------------------------

   291 // testUpdateState

   292 // -------------------------------------------------------------------------------------------------

   293 //

   294 void TestProgressBar::testUpdateState()

   295 {

   296     MPX_ENTER_EXIT(_L("TestProgressBar::testUpdateState()"));

   297 

   298     setup();

   299 

   300     // test for 1st block of cases

   301     mProgBar->updateState( EPbStatePlaying );

   302     QVERIFY( mProgBar->mProgressSlider->isEnabled() );

   303 

   304     // test for 2nd block of cases

   305     mProgBar->updateState( EPbStateBuffering );

   306     QVERIFY( ! mProgBar->mProgressSlider->isEnabled() );

   307 

   308     cleanup();

   309 }

   310 

   311 // -------------------------------------------------------------------------------------------------

   312 // testDurationChanged

   313 // -------------------------------------------------------------------------------------------------

   314 //

   315 void TestProgressBar::testDurationChanged()

   316 {

   317     MPX_ENTER_EXIT(_L("TestProgressBar::testDurationChanged()"));

   318 

   319     setup();

   320 

   321     int duration = 120;

   322     mProgBar->durationChanged( duration );

   323 

   324     QVERIFY( mProgBar->mDuration == duration );

   325     QVERIFY( mProgBar->mProgressSlider->maximum() == duration );

   326     QVERIFY( mProgBar->mProgressSlider->maxText() == "2:00" );

   327 

   328     cleanup();

   329 }

   330 

   331 // -------------------------------------------------------------------------------------------------

   332 // testPositionChanged

   333 // -------------------------------------------------------------------------------------------------

   334 //

   335 void TestProgressBar::testPositionChanged()

   336 {

   337     MPX_ENTER_EXIT(_L("TestProgressBar::testPositionChanged()"));

   338 

   339     setup();

   340 

   341     //

   342     // position < duration

   343     //

   344     int position = 60;

   345     int duration = 120;

   346     mProgBar->durationChanged( duration );

   347 

   348     mProgBar->mSliderDragging = false;

   349     mProgBar->positionChanged( position );

   350 

   351     QVERIFY( mProgBar->mProgressSlider->minText() == "1:00" );

   352     QVERIFY( mProgBar->mProgressSlider->sliderValue() == position );

   353     QVERIFY( mProgBar->mProgressSlider->progressValue() == position );

   354 

   355     //

   356     // position > duration

   357     //

   358     position = 130;

   359 

   360     mProgBar->positionChanged( position );

   361 

   362     QVERIFY( mProgBar->mProgressSlider->minText() == "2:00" );

   363     QVERIFY( mProgBar->mProgressSlider->sliderValue() == duration );

   364     QVERIFY( mProgBar->mProgressSlider->progressValue() == duration );

   365 

   366     //

   367     // position < 0

   368     //

   369     position = -1;

   370 

   371     mProgBar->positionChanged( position );

   372 

   373     QVERIFY( mProgBar->mProgressSlider->minText() == "0:00" );

   374     QVERIFY( mProgBar->mProgressSlider->sliderValue() == 0 );

   375     QVERIFY( mProgBar->mProgressSlider->progressValue() == 0 );

   376 

   377     //

   378     // duration >= 1 hour

   379     //

   380     duration = 3600;

   381     mProgBar->durationChanged( duration );

   382 

   383     position = 5;

   384     mProgBar->positionChanged( position );

   385 

   386     QVERIFY( mProgBar->mProgressSlider->minText() == "0:00:05" );

   387     QVERIFY( mProgBar->mProgressSlider->sliderValue() == position );

   388     QVERIFY( mProgBar->mProgressSlider->progressValue() == position );

   389     cleanup();

   390 }

   391 

   392 // -------------------------------------------------------------------------------------------------

   393 // testHandleSeekingTimeout

   394 // -------------------------------------------------------------------------------------------------

   395 //

   396 void TestProgressBar::testHandleSeekingTimeout()

   397 {

   398     MPX_ENTER_EXIT(_L("TestProgressBar::testHandleSeekingTimeout()"));

   399 

   400     setup();

   401 

   402     mProgBar->mDraggingPosition = 10;

   403     mProgBar->mDuration = 30;

   404     mProgBar->mSetPosition = 0;

   405 

   406     connect( this, SIGNAL( commandSignal() ), mProgBar, SLOT( handleSeekingTimeout() ) );

   407     emit commandSignal();

   408 

   409     QVERIFY( mController->mCommand == EMPXPbvCmdSetPosition );

   410     QVERIFY( mController->mValue == mProgBar->mDraggingPosition );

   411 

   412     cleanup();

   413 }

   414 

   415 // End of file