videoplayback/hbvideoplaybackview/tsrc/testprogressbar/src/testprogressbar.cpp
changeset 36 8aed59de29f9
parent 34 bbb98528c666
child 24 7d93ee07fb27
equal deleted inserted replaced
35:3738fe97f027 36:8aed59de29f9
    13 *
    13 *
    14 * Description:   tester for methods in TestMPXVideoPlaybackButtonBar
    14 * Description:   tester for methods in TestMPXVideoPlaybackButtonBar
    15 * 
    15 * 
    16 */
    16 */
    17 
    17 
    18 // Version : %version:  1 %
    18 // Version : %version:  3 %
    19 
    19 
    20 
    20 
    21 #include <qdebug>
    21 #include <qdebug>
    22 #include <hbmainwindow.h>
    22 #include <hbmainwindow.h>
    23 #include <hbapplication.h>
    23 #include <hbapplication.h>
    24 #include <qgraphicssceneevent>
    24 #include <qgraphicssceneevent>
    25 #include <hbprogressbar.h>
    25 #include <hbprogressslider.h>
    26 
    26 
    27 
    27 
    28 #include "testprogressbar.h"
    28 #include "testprogressbar.h"
    29 #include "mpxvideoplaybackviewfiledetails.h"
    29 #include "mpxvideoplaybackviewfiledetails.h"
    30 #include "mpxvideoplaybackcontrolscontroller.h"
    30 #include "mpxvideoplaybackcontrolscontroller.h"
    31 #include "hblabel.h"
       
    32 
    31 
    33 #define private public
    32 #define private public
    34 #include "mpxvideoplaybackprogressbar.h"
    33 #include "mpxvideoplaybackprogressbar.h"
    35 #undef private
    34 #undef private
    36 
    35 
    37 // ---------------------------------------------------------------------------
    36 // -------------------------------------------------------------------------------------------------
    38 // main
    37 // main
    39 // ---------------------------------------------------------------------------
    38 // -------------------------------------------------------------------------------------------------
    40 //
    39 //
    41 int main(int argc, char *argv[])
    40 int main(int argc, char *argv[])
    42 {
    41 {
    43     MPX_ENTER_EXIT(_L("TestProgressBar::Main()"));
    42     MPX_ENTER_EXIT(_L("TestProgressBar::Main()"));
    44 
    43 
    48     TestProgressBar tv;
    47     TestProgressBar tv;
    49 
    48 
    50     char *pass[3];
    49     char *pass[3];
    51     pass[0] = argv[0];
    50     pass[0] = argv[0];
    52     pass[1] = "-o";
    51     pass[1] = "-o";
    53     pass[2] = "c:\\data\\TestProgressBar.txt";
    52     pass[2] = "c:\\data\\testprogressbar.txt";
    54     
    53     
    55     int res = QTest::qExec(&tv, 3, pass);
    54     int res = QTest::qExec(&tv, 3, pass);
    56     
    55     
    57     return res;
    56     return res;
    58 }
    57 }
    59 
    58 
    60 
    59 
    61 // ---------------------------------------------------------------------------
    60 // -------------------------------------------------------------------------------------------------
    62 // init
    61 // init
    63 // ---------------------------------------------------------------------------
    62 // -------------------------------------------------------------------------------------------------
    64 //
    63 //
    65 void TestProgressBar::init()
    64 void TestProgressBar::init()
    66 {
    65 {
    67     MPX_ENTER_EXIT(_L("TestProgressBar::init()"));
    66     MPX_ENTER_EXIT(_L("TestProgressBar::init()"));
    68 }
    67 }
    69 
    68 
    70 // ---------------------------------------------------------------------------
    69 // -------------------------------------------------------------------------------------------------
    71 // setup
    70 // setup
    72 // ---------------------------------------------------------------------------
    71 // -------------------------------------------------------------------------------------------------
    73 //
    72 //
    74 void TestProgressBar::setup()
    73 void TestProgressBar::setup()
    75 {
    74 {
    76     MPX_ENTER_EXIT(_L("TestProgressBar::setup()"));
    75     MPX_ENTER_EXIT(_L("TestProgressBar::setup()"));
    77 
    76 
    79     mProgBar = new QMPXVideoPlaybackProgressBar( mController );
    78     mProgBar = new QMPXVideoPlaybackProgressBar( mController );
    80 
    79 
    81     mProgBar->initialize();
    80     mProgBar->initialize();
    82 }
    81 }
    83 
    82 
    84 // ---------------------------------------------------------------------------
    83 // -------------------------------------------------------------------------------------------------
    85 // cleanup
    84 // cleanup
    86 // ---------------------------------------------------------------------------
    85 // -------------------------------------------------------------------------------------------------
    87 //
    86 //
    88 void TestProgressBar::cleanup()
    87 void TestProgressBar::cleanup()
    89 {
    88 {
    90     MPX_ENTER_EXIT(_L("TestProgressBar::cleanup()"));
    89     MPX_ENTER_EXIT(_L("TestProgressBar::cleanup()"));
    91 
    90 
   100         delete mProgBar;
    99         delete mProgBar;
   101         mProgBar = NULL;
   100         mProgBar = NULL;
   102     }
   101     }
   103 }
   102 }
   104 
   103 
   105 // ---------------------------------------------------------------------------
   104 // -------------------------------------------------------------------------------------------------
   106 // testMousePressEvent
   105 // testHandleSliderPressed
   107 // ---------------------------------------------------------------------------
   106 // -------------------------------------------------------------------------------------------------
   108 //
   107 //
   109 void TestProgressBar::testMousePressEvent()
   108 void TestProgressBar::testHandleSliderPressed()
   110 {
   109 {
   111     MPX_ENTER_EXIT(_L("TestProgressBar::testMousePressEvent()"));
   110     MPX_ENTER_EXIT(_L("TestProgressBar::testHandleSliderPressed()"));
   112 
   111 
   113     setup();    
   112     setup();
       
   113 
       
   114     //
       
   115     // If it is playing state
       
   116     //
   114     mController->mState = EPbStatePlaying;        
   117     mController->mState = EPbStatePlaying;        
   115     QGraphicsSceneMouseEvent* event = new QGraphicsSceneMouseEvent( QEvent::GraphicsSceneMousePress );       
   118 
   116     event->setAccepted( false );    
   119     emit mProgBar->mProgressSlider->press();
   117 
   120 
   118     mProgBar->mousePressEvent(event);
   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 );
   119     
   178     
   120     QVERIFY( mController->mTimerAction == EMPXTimerCancel );        
   179     //
   121     QVERIFY( mProgBar->mNeedToResumeAfterSetPosition );    
   180     // 0 <= moved position < duration
   122     QVERIFY( event->isAccepted() );      
   181     //
   123     
   182     mProgBar->mProgressSlider->mSliderValue = 60;
   124     delete event;
   183     mController->mTimerAction = EMPXTimerCancel;
   125     event = NULL;     
   184     mController->mCommand = EMPXPbvCmdStop;        
   126 }
   185 
   127 
   186     emit mProgBar->mProgressSlider->release();
   128 // ---------------------------------------------------------------------------
   187     QVERIFY( mController->mTimerAction == EMPXTimerReset );
   129 // testMouseReleaseEvent
   188     QVERIFY( ! mProgBar->mSliderDragging );
   130 // ---------------------------------------------------------------------------
   189     QVERIFY( mController->mCommand == EMPXPbvCmdSetPosition );
   131 //
   190     QVERIFY( mController->mValue == mProgBar->mProgressSlider->mSliderValue );
   132 void TestProgressBar::testMouseReleaseEvent()
   191 
   133 {
   192     cleanup();
   134     MPX_ENTER_EXIT(_L("TestProgressBar::testMouseReleaseEvent()"));
   193 }
   135 
   194 
   136     setup();
   195 // -------------------------------------------------------------------------------------------------
   137     QGraphicsSceneMouseEvent* event = new QGraphicsSceneMouseEvent( QEvent::GraphicsSceneMouseRelease );       
   196 // testHandleSliderMoved
   138     event->setAccepted( false );     
   197 // -------------------------------------------------------------------------------------------------
   139     
   198 //
   140     mProgBar->mouseReleaseEvent(event);
   199 void TestProgressBar::testHandleSliderMoved()
   141     
   200 {
   142     QVERIFY( mController->mTimerAction == EMPXTimerReset );    
   201     MPX_ENTER_EXIT(_L("TestProgressBar::testHandleSliderMoved()"));
   143     QVERIFY( event->isAccepted() );      
   202 
   144     
   203     setup();
   145     delete event;
   204 
   146     event = NULL; 
   205     //
   147 }
   206     // If user is dragging the slider
   148 
   207     //
   149 // ---------------------------------------------------------------------------
   208     int movedPositoin = 5;
   150 // testMouseMoveEvent
   209     mProgBar->mDuration = 20;
   151 // ---------------------------------------------------------------------------
   210     mProgBar->mSliderDragging = true;
   152 //
   211     emit mProgBar->mProgressSlider->move( movedPositoin );
   153 void TestProgressBar::testMouseMoveEvent()
   212 
   154 {
   213     QVERIFY( mProgBar->mDraggingPosition == movedPositoin );
   155     MPX_ENTER_EXIT(_L("TestProgressBar::testMouseMoveEvent()"));
   214     QVERIFY( mProgBar->mProgressSlider->progressValue() == movedPositoin );
   156 
   215     QVERIFY( mProgBar->mProgressSlider->sliderValue() == movedPositoin );
   157     setup();
   216 
   158     QGraphicsSceneMouseEvent* event = new QGraphicsSceneMouseEvent( QEvent::GraphicsSceneMouseMove );       
   217     //
   159     event->setAccepted( false );
   218     // If user isnot dragging the slider and movedPosition > mDuration
   160     mProgBar->mDuration = 0;
   219     //
   161     
   220     movedPositoin = 30;
   162     mProgBar->mouseMoveEvent(event);
   221     mProgBar->mSliderDragging = false;
   163         
   222 
   164     QVERIFY( mProgBar->mPositionLabel->mTextSet );
   223     emit mProgBar->mProgressSlider->move( movedPositoin );
   165     QVERIFY( event->isAccepted() );      
   224 
   166     
   225     QVERIFY( mProgBar->mProgressSlider->progressValue() == mProgBar->mDuration );
   167     delete event;
   226     QVERIFY( mProgBar->mProgressSlider->sliderValue() == mProgBar->mDuration );
   168     event = NULL; 
   227     QVERIFY( mController->mCommand == EMPXPbvCmdEndOfClip );
   169 }
   228 
   170 
   229     //
   171 // ---------------------------------------------------------------------------
   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 // -------------------------------------------------------------------------------------------------
   172 // testUpdateWithFileDetails
   246 // testUpdateWithFileDetails
   173 // ---------------------------------------------------------------------------
   247 // -------------------------------------------------------------------------------------------------
   174 //
   248 //
   175 void TestProgressBar::testUpdateWithFileDetails()
   249 void TestProgressBar::testUpdateWithFileDetails()
   176 {
   250 {
   177     MPX_ENTER_EXIT(_L("TestProgressBar::testUpdateWithFileDetails()"));
   251     MPX_ENTER_EXIT(_L("TestProgressBar::testUpdateWithFileDetails()"));
   178 
   252 
   179     setup();
   253     setup();
   180     
   254 
   181     // test for live
       
   182     mController->mFileDetails->mPlaybackMode = EMPXVideoLiveStreaming;    
       
   183     mProgBar->updateWithFileDetails( mController->mFileDetails );    
       
   184     QVERIFY( mProgBar->mDurationLabel->mLabelText == "Live" );
       
   185     
       
   186     // test for tv-out
   255     // test for tv-out
   187     mController->mFileDetails->mPlaybackMode = EMPXVideoLocal; 
   256     mController->mFileDetails->mPlaybackMode = EMPXVideoLocal; 
   188     mController->mFileDetails->mTvOutConnected = true;
   257     mController->mFileDetails->mTvOutConnected = true;
   189     mController->mFileDetails->mTvOutPlayAllowed = false;
   258     mController->mFileDetails->mTvOutPlayAllowed = false;
   190     mProgBar->updateWithFileDetails( mController->mFileDetails );
   259     mProgBar->updateWithFileDetails( mController->mFileDetails );
       
   260     QVERIFY( ! mProgBar->mProgressSlider->isEnabled() );
       
   261 
       
   262     // live streaming
       
   263     mController->mFileDetails->mPlaybackMode = EMPXVideoLiveStreaming; 
       
   264     mProgBar->updateWithFileDetails( mController->mFileDetails );
       
   265     QVERIFY( ! mProgBar->mProgressSlider->isEnabled() );
       
   266 
       
   267     // other cases
       
   268     mController->mFileDetails->mPlaybackMode = EMPXVideoLocal; 
       
   269     mController->mFileDetails->mTvOutConnected = false;
       
   270     mProgBar->updateWithFileDetails( mController->mFileDetails );
       
   271     QVERIFY( mProgBar->mProgressSlider->isEnabled() );
       
   272 
       
   273     cleanup();
       
   274 }
       
   275 
       
   276 // -------------------------------------------------------------------------------------------------
       
   277 // testUpdateState
       
   278 // -------------------------------------------------------------------------------------------------
       
   279 //
       
   280 void TestProgressBar::testUpdateState()
       
   281 {
       
   282     MPX_ENTER_EXIT(_L("TestProgressBar::testUpdateState()"));
       
   283 
       
   284     setup();
       
   285 
       
   286     // test for 1st block of cases
       
   287     mProgBar->updateState( EPbStatePlaying );
       
   288     QVERIFY( mProgBar->isEnabled() );
       
   289 
       
   290     // test for 2nd block of cases
       
   291     mProgBar->updateState( EPbStateBuffering );
   191     QVERIFY( ! mProgBar->isEnabled() );
   292     QVERIFY( ! mProgBar->isEnabled() );
   192         
   293 
   193 }
   294     cleanup();
   194 
   295 }
   195 // ---------------------------------------------------------------------------
   296 
   196 // testUpdateState
   297 // -------------------------------------------------------------------------------------------------
   197 // ---------------------------------------------------------------------------
       
   198 //
       
   199 void TestProgressBar::testUpdateState()
       
   200 {
       
   201     MPX_ENTER_EXIT(_L("TestProgressBar::testUpdateState()"));
       
   202 
       
   203     setup();
       
   204     
       
   205     // test for 1st block of cases
       
   206     mController->mFileDetails->mPlaybackMode = EMPXVideoLiveStreaming; 
       
   207     mController->mViewMode =  EAudioOnlyView;
       
   208     mProgBar->updateState(EPbStatePlaying);
       
   209     QVERIFY( mProgBar->mDurationLabel->mLabelText == "Live" );    
       
   210     
       
   211     // test for 2nd block of cases
       
   212     mProgBar->updateState(EPbStateBuffering);
       
   213     QVERIFY( ! mProgBar->isEnabled() );
       
   214     
       
   215 }
       
   216 
       
   217 // ---------------------------------------------------------------------------
       
   218 // testDurationChanged
   298 // testDurationChanged
   219 // ---------------------------------------------------------------------------
   299 // -------------------------------------------------------------------------------------------------
   220 //
   300 //
   221 void TestProgressBar::testDurationChanged()
   301 void TestProgressBar::testDurationChanged()
   222 {
   302 {
   223     MPX_ENTER_EXIT(_L("TestProgressBar::testDurationChanged()"));
   303     MPX_ENTER_EXIT(_L("TestProgressBar::testDurationChanged()"));
   224 
   304 
   225     setup();
   305     setup();
   226     
   306 
   227     mProgBar->durationChanged( 120 );
   307     int duration = 120;
   228     
   308     mProgBar->durationChanged( duration );
   229     QVERIFY( mProgBar->mDuration == 120 );
   309 
   230     QVERIFY( mProgBar->mProgressSlider->maximum() == 120 );
   310     QVERIFY( mProgBar->mDuration == duration );
   231     
   311     QVERIFY( mProgBar->mProgressSlider->maximum() == duration );
   232 }
   312     QVERIFY( mProgBar->mProgressSlider->maxText() == "2:00" );
   233 
   313 
   234 // ---------------------------------------------------------------------------
   314     cleanup();
       
   315 }
       
   316 
       
   317 // -------------------------------------------------------------------------------------------------
   235 // testPositionChanged
   318 // testPositionChanged
   236 // ---------------------------------------------------------------------------
   319 // -------------------------------------------------------------------------------------------------
   237 //
   320 //
   238 void TestProgressBar::testPositionChanged()
   321 void TestProgressBar::testPositionChanged()
   239 {
   322 {
   240     MPX_ENTER_EXIT(_L("TestProgressBar::testPositionChanged()"));
   323     MPX_ENTER_EXIT(_L("TestProgressBar::testPositionChanged()"));
   241 
   324 
   242     setup();
   325     setup();
   243     mProgBar->mDragging = false;
   326 
   244     
   327     //
   245     mProgBar->positionChanged( 60 );
   328     // position < duration
   246     QVERIFY( mProgBar->mPositionLabel->mTextSet );
   329     //
   247         
   330     int position = 60;
       
   331     int duration = 120;
       
   332     mProgBar->durationChanged( duration );
       
   333 
       
   334     mProgBar->mSliderDragging = false;
       
   335     mProgBar->positionChanged( position );
       
   336 
       
   337     QVERIFY( mProgBar->mProgressSlider->minText() == "1:00" );
       
   338     QVERIFY( mProgBar->mProgressSlider->sliderValue() == position );
       
   339     QVERIFY( mProgBar->mProgressSlider->progressValue() == position );
       
   340 
       
   341     //
       
   342     // position > duration
       
   343     //
       
   344     position = 130;
       
   345 
       
   346     mProgBar->positionChanged( position );
       
   347 
       
   348     QVERIFY( mProgBar->mProgressSlider->minText() == "2:00" );
       
   349     QVERIFY( mProgBar->mProgressSlider->sliderValue() == duration );
       
   350     QVERIFY( mProgBar->mProgressSlider->progressValue() == duration );
       
   351 
       
   352     //
       
   353     // position < 0
       
   354     //
       
   355     position = -1;
       
   356 
       
   357     mProgBar->positionChanged( position );
       
   358 
       
   359     QVERIFY( mProgBar->mProgressSlider->minText() == "0:00" );
       
   360     QVERIFY( mProgBar->mProgressSlider->sliderValue() == 0 );
       
   361     QVERIFY( mProgBar->mProgressSlider->progressValue() == 0 );
       
   362 
       
   363     //
       
   364     // duration >= 1 hour
       
   365     //
       
   366     duration = 3600;
       
   367     mProgBar->durationChanged( duration );
       
   368 
       
   369     position = 5;
       
   370     mProgBar->positionChanged( position );
       
   371 
       
   372     QVERIFY( mProgBar->mProgressSlider->minText() == "0:00:05" );
       
   373     QVERIFY( mProgBar->mProgressSlider->sliderValue() == position );
       
   374     QVERIFY( mProgBar->mProgressSlider->progressValue() == position );
       
   375     cleanup();
       
   376 }
       
   377 
       
   378 // -------------------------------------------------------------------------------------------------
       
   379 // testHandleSeekingTimeout
       
   380 // -------------------------------------------------------------------------------------------------
       
   381 //
       
   382 void TestProgressBar::testHandleSeekingTimeout()
       
   383 {
       
   384     MPX_ENTER_EXIT(_L("TestProgressBar::testHandleSeekingTimeout()"));
       
   385 
       
   386     setup();
       
   387 
       
   388     mProgBar->mDraggingPosition = 10; 
       
   389     mProgBar->mDuration = 30;
       
   390     mProgBar->mSetPosition = 0;
       
   391 
       
   392     connect( this, SIGNAL( commandSignal() ), mProgBar, SLOT( handleSeekingTimeout() ) );
       
   393     emit commandSignal();
       
   394 
       
   395     QVERIFY( mController->mCommand == EMPXPbvCmdSetPosition );
       
   396     QVERIFY( mController->mValue == mProgBar->mDraggingPosition );
       
   397 
       
   398     cleanup();
   248 }
   399 }
   249 
   400 
   250 // End of file
   401 // End of file