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:  4 %

    19 

    20 

    21 #include <qdebug>

    22 #include <hbmainwindow.h>

    23 #include <hbapplication.h>

    24 

    25 #include "testmpxvideoplaybackbuttonbar.h"

    26 #include "mpxvideoplaybackviewfiledetails.h"

    27 #include "mpxvideoplaybackcontrolscontroller.h"

    28 #include "hbpushbutton.h"

    29 

    30 #define private public

    31 #include "mpxvideoplaybackbuttonbar.h"

    32 #undef private

    33 

    34 // ---------------------------------------------------------------------------

    35 // main

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

    37 //

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

    39 {

    40     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::Main()"));

    41 

    42     HbApplication app(argc, argv);

    43     HbMainWindow window;

    44 

    45     TestMPXVideoPlaybackButtonBar tv;

    46 

    47     char *pass[3];

    48     pass[0] = argv[0];

    49     pass[1] = "-o";

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

    51     

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

    53     

    54     return res;

    55 }

    56 

    57 

    58 // ---------------------------------------------------------------------------

    59 // init

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

    61 //

    62 void TestMPXVideoPlaybackButtonBar::init( bool attachOperation )

    63 {

    64     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::init()"));

    65 

    66     mController = new QMPXVideoPlaybackControlsController( attachOperation );   

    67     mButtonBar = new QMPXVideoPlaybackButtonBar( mController );

    68 

    69     mButtonBar->initialize();

    70 }

    71 

    72 // ---------------------------------------------------------------------------

    73 // cleanup

    74 // ---------------------------------------------------------------------------

    75 //

    76 void TestMPXVideoPlaybackButtonBar::cleanup()

    77 {

    78     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::cleanup()"));

    79 

    80     if ( mController )

    81     {

    82         delete mController;

    83         mController = NULL;

    84     }

    85 

    86     if ( mButtonBar )

    87     {

    88         delete mButtonBar;

    89         mButtonBar = NULL;

    90     }

    91 }

    92 

    93 // ---------------------------------------------------------------------------

    94 // testPlay

    95 // ---------------------------------------------------------------------------

    96 //

    97 void TestMPXVideoPlaybackButtonBar::testPlay()

    98 {

    99     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testPlay()"));

   100 

   101     init();

   102 

   103     mButtonBar->mButtons[EMPXButtonPlay]->release();

   104 

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

   106     QVERIFY( mController->mCommand == EMPXPbvCmdPlay );

   107 

   108     cleanup();

   109 }

   110 

   111 // ---------------------------------------------------------------------------

   112 // testLongTapOnFF

   113 // ---------------------------------------------------------------------------

   114 //

   115 void TestMPXVideoPlaybackButtonBar::testLongTapOnFF()

   116 {

   117     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testLongTapOnFF()"));

   118 

   119     init();

   120 

   121     //

   122     // Start seeking

   123     //

   124     mButtonBar->mButtons[EMPXButtonFF]->press();

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

   126 

   127     mButtonBar->mButtons[EMPXButtonFF]->pressing();

   128 

   129     QVERIFY( mButtonBar->mSeekingState == EMPXFastForwarding );

   130     QVERIFY( mButtonBar->mButtons[EMPXButtonFF]->mSelected == true );

   131     QVERIFY( mController->mCommand == EMPXPbvCmdSeekForward );

   132 

   133     //

   134     // End seeking

   135     //

   136     mButtonBar->mButtons[EMPXButtonFF]->release();

   137 

   138     QVERIFY( mButtonBar->mSeekingState == EMPXNotSeeking );

   139     QVERIFY( mButtonBar->mButtons[EMPXButtonFF]->mSelected == false );

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

   141     QVERIFY( mController->mCommand == EMPXPbvCmdEndSeek );

   142 

   143     cleanup();

   144 }

   145 

   146 // ---------------------------------------------------------------------------

   147 // testLongTapOnRW

   148 // ---------------------------------------------------------------------------

   149 //

   150 void TestMPXVideoPlaybackButtonBar::testLongTapOnRW()

   151 {

   152     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testLongTapOnRW()"));

   153 

   154     init();

   155 

   156     //

   157     // Start seeking

   158     //

   159     mButtonBar->mButtons[EMPXButtonRW]->press();

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

   161 

   162     mButtonBar->mButtons[EMPXButtonRW]->pressing();

   163 

   164     QVERIFY( mButtonBar->mSeekingState == EMPXRewinding );

   165     QVERIFY( mButtonBar->mButtons[EMPXButtonRW]->mSelected == true );

   166     QVERIFY( mController->mCommand == EMPXPbvCmdSeekBackward );

   167 

   168     //

   169     // End seeking

   170     //

   171     mButtonBar->mButtons[EMPXButtonRW]->release();

   172 

   173     QVERIFY( mButtonBar->mSeekingState == EMPXNotSeeking );

   174     QVERIFY( mButtonBar->mButtons[EMPXButtonRW]->mSelected == false );

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

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

   177 

   178     cleanup();

   179 }

   180 

   181 // ---------------------------------------------------------------------------

   182 // testShortTapOnFF

   183 // ---------------------------------------------------------------------------

   184 //

   185 void TestMPXVideoPlaybackButtonBar::testShortTapOnFF()

   186 {

   187     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testShortTapOnFF()"));

   188 

   189     init();

   190 

   191     //

   192     // If mPostion + KMPXFastForward < mDuration

   193     //

   194     mButtonBar->mPosition = 30;

   195     mButtonBar->mDuration = 70;

   196     mButtonBar->mButtons[EMPXButtonFF]->release();

   197 

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

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

   200     QVERIFY( mController->mCommandValue == mButtonBar->mPosition + KMPXFastForward );

   201 

   202     //

   203     // If mPostion + KMPXFastForward < mDuration

   204     //

   205     mButtonBar->mDuration = 50;

   206     mController->mCommand = EMPXPbvCmdPlay;

   207 

   208     mButtonBar->mButtons[EMPXButtonFF]->release();

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

   210     QVERIFY( mController->mCommand == EMPXPbvCmdPlay );

   211 

   212     cleanup();

   213 }

   214 

   215 // ---------------------------------------------------------------------------

   216 // testShortTapOnRW

   217 // ---------------------------------------------------------------------------

   218 //

   219 void TestMPXVideoPlaybackButtonBar::testShortTapOnRW()

   220 {

   221     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testShortTapOnRW()"));

   222 

   223     init();

   224 

   225     //

   226     // If mPostion + KMPXRewind > 0

   227     //

   228     mButtonBar->mPosition = 30;

   229     mButtonBar->mButtons[EMPXButtonRW]->release();

   230 

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

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

   233     QVERIFY( mController->mCommandValue == mButtonBar->mPosition + KMPXRewind );

   234 

   235     //

   236     // If mPostion + KMPXRewind < 0

   237     //

   238     mButtonBar->mPosition = 4;

   239     mButtonBar->mButtons[EMPXButtonRW]->release();

   240 

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

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

   243     QVERIFY( mController->mCommandValue == 0 );

   244 

   245     cleanup();

   246 }

   247 

   248 // ---------------------------------------------------------------------------

   249 // testPause

   250 // ---------------------------------------------------------------------------

   251 //

   252 void TestMPXVideoPlaybackButtonBar::testPause()

   253 {

   254     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testPause()"));

   255 

   256     init();

   257 

   258     mButtonBar->mButtons[EMPXButtonPause]->release();

   259 

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

   261     QVERIFY( mController->mCommand == EMPXPbvCmdPause );

   262 

   263     cleanup();

   264 }

   265 

   266 // ---------------------------------------------------------------------------

   267 // testChangeAspectRatio

   268 // ---------------------------------------------------------------------------

   269 //

   270 void TestMPXVideoPlaybackButtonBar::testChangeAspectRatio()

   271 {

   272     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testChangeAspectRatio()"));

   273 

   274     init();

   275 

   276     //

   277     // Test natural

   278     //

   279     mButtonBar->mButtons[EMPXButtonNatural]->setVisible( true );

   280     mButtonBar->mButtons[EMPXButtonStretch]->setVisible( false );

   281     mButtonBar->mButtons[EMPXButtonZoom]->setVisible( false );

   282     mButtonBar->mButtons[EMPXButtonNatural]->release();

   283 

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

   285     QVERIFY( mController->mCommand == EMPXPbvCmdNaturalAspectRatio );

   286 

   287     //

   288     // Test stretch

   289     //

   290     mButtonBar->mButtons[EMPXButtonNatural]->setVisible( false );

   291     mButtonBar->mButtons[EMPXButtonStretch]->setVisible( true );

   292     mButtonBar->mButtons[EMPXButtonZoom]->setVisible( false );

   293     mButtonBar->mButtons[EMPXButtonStretch]->release();

   294 

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

   296     QVERIFY( mController->mCommand == EMPXPbvCmdStretchAspectRatio );

   297 

   298     //

   299     // Test stretch

   300     //

   301     mButtonBar->mButtons[EMPXButtonNatural]->setVisible( false );

   302     mButtonBar->mButtons[EMPXButtonStretch]->setVisible( false );

   303     mButtonBar->mButtons[EMPXButtonZoom]->setVisible( true );

   304     mButtonBar->mButtons[EMPXButtonZoom]->release();

   305 

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

   307     QVERIFY( mController->mCommand == EMPXPbvCmdZoomAspectRatio );

   308 

   309     cleanup();

   310 }

   311 

   312 // ---------------------------------------------------------------------------

   313 // testUpdateState

   314 // ---------------------------------------------------------------------------

   315 //

   316 void TestMPXVideoPlaybackButtonBar::testUpdateState()

   317 {

   318     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testUpdateState()"));

   319 

   320     init();

   321 

   322     //

   323     // Playing

   324     //

   325     TMPXPlaybackState state = EPbStatePlaying;

   326     mButtonBar->updateState( state );

   327 

   328     QVERIFY( mButtonBar->mButtons[EMPXButtonPlay]->mVisible == false );

   329     QVERIFY( mButtonBar->mButtons[EMPXButtonPause]->mVisible == true );

   330 

   331     //

   332     // Paused

   333     //

   334     state = EPbStatePaused;

   335     mButtonBar->updateState( state );

   336 

   337     QVERIFY( mButtonBar->mButtons[EMPXButtonPlay]->mVisible == true );

   338     QVERIFY( mButtonBar->mButtons[EMPXButtonPause]->mVisible == false );

   339 

   340     //

   341     // Not initialized

   342     //

   343     state = EPbStateNotInitialised;

   344     mButtonBar->updateState( state );

   345 

   346     QVERIFY( mButtonBar->isEnabled() == false );

   347 

   348     cleanup();

   349 }

   350 

   351 // ---------------------------------------------------------------------------

   352 // testAspectRatioChanged

   353 // ---------------------------------------------------------------------------

   354 //

   355 void TestMPXVideoPlaybackButtonBar::testAspectRatioChanged()

   356 {

   357     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testAspectRatioChanged()"));

   358 

   359     init();

   360 

   361     //

   362     // Natural

   363     //

   364     int aspectRatio = EMMFNatural;

   365     mButtonBar->aspectRatioChanged( aspectRatio );

   366     QVERIFY( mButtonBar->mButtons[EMPXButtonNatural]->mVisible == false );

   367     QVERIFY( mButtonBar->mButtons[EMPXButtonStretch]->mVisible == true );

   368     QVERIFY( mButtonBar->mButtons[EMPXButtonZoom]->mVisible == false );

   369 

   370     //

   371     // Stretch

   372     //

   373     aspectRatio = EMMFStretch;

   374     mButtonBar->aspectRatioChanged( aspectRatio );

   375     QVERIFY( mButtonBar->mButtons[EMPXButtonNatural]->mVisible == false );

   376     QVERIFY( mButtonBar->mButtons[EMPXButtonStretch]->mVisible == false );

   377     QVERIFY( mButtonBar->mButtons[EMPXButtonZoom]->mVisible == true );

   378 

   379     //

   380     // Zoom

   381     //

   382     aspectRatio = EMMFZoom;

   383     mButtonBar->aspectRatioChanged( aspectRatio );

   384     QVERIFY( mButtonBar->mButtons[EMPXButtonNatural]->mVisible == true );

   385     QVERIFY( mButtonBar->mButtons[EMPXButtonStretch]->mVisible == false );

   386     QVERIFY( mButtonBar->mButtons[EMPXButtonZoom]->mVisible == false );

   387 

   388     cleanup();

   389 }

   390 

   391 // ---------------------------------------------------------------------------

   392 // testHandleButtonPressed

   393 // ---------------------------------------------------------------------------

   394 //

   395 void TestMPXVideoPlaybackButtonBar::testHandleButtonPressed()

   396 {

   397     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testHandleButtonPressed()"));

   398 

   399     init();

   400 

   401     mButtonBar->mButtons[EMPXButtonNatural]->press();

   402 

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

   404 

   405     cleanup();

   406 }

   407 

   408 // ---------------------------------------------------------------------------

   409 // testUpdateWithFileDetails

   410 // ---------------------------------------------------------------------------

   411 //

   412 void TestMPXVideoPlaybackButtonBar::testUpdateWithFileDetails()

   413 {

   414     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testUpdateWithFileDetails()"));

   415 

   416     init();

   417 

   418     QMPXVideoPlaybackViewFileDetails *details = mController->fileDetails();

   419 

   420     details->mVideoEnabled = true;

   421     details->mVideoHeight = 1;

   422     details->mVideoWidth = 1;

   423     details->mTvOutConnected = false;

   424     details->mTvOutPlayAllowed = true;

   425     details->mSeekable = true;

   426     details->mPausableStream = true;

   427 

   428     mButtonBar->updateWithFileDetails( details );

   429     QVERIFY( mButtonBar->mButtons[EMPXButtonNatural]->mEnabled == true );

   430     QVERIFY( mButtonBar->mButtons[EMPXButtonStretch]->mEnabled == true );

   431     QVERIFY( mButtonBar->mButtons[EMPXButtonZoom]->mEnabled == true );

   432     QVERIFY( mButtonBar->mButtons[EMPXButtonRW]->mEnabled == true );

   433     QVERIFY( mButtonBar->mButtons[EMPXButtonPause]->mEnabled == true );

   434     QVERIFY( mButtonBar->mButtons[EMPXButtonPlay]->mEnabled == true );

   435     QVERIFY( mButtonBar->mButtons[EMPXButtonDetails]->mEnabled == true );

   436 

   437     details->mVideoEnabled = false;

   438     details->mVideoHeight = 0;

   439     details->mVideoWidth = 1;

   440     details->mTvOutConnected = true;

   441     details->mTvOutPlayAllowed = true;

   442     details->mSeekable = false;

   443     details->mPausableStream = false;

   444 

   445     mButtonBar->updateWithFileDetails( details );

   446     QVERIFY( mButtonBar->mButtons[EMPXButtonNatural]->mEnabled == false );

   447     QVERIFY( mButtonBar->mButtons[EMPXButtonStretch]->mEnabled == false );

   448     QVERIFY( mButtonBar->mButtons[EMPXButtonZoom]->mEnabled == false );

   449     QVERIFY( mButtonBar->mButtons[EMPXButtonRW]->mEnabled == false );

   450     QVERIFY( mButtonBar->mButtons[EMPXButtonPause]->mEnabled == false );

   451     QVERIFY( mButtonBar->mButtons[EMPXButtonPlay]->mEnabled == true );

   452     QVERIFY( mButtonBar->mButtons[EMPXButtonDetails]->mEnabled == false );

   453 

   454     cleanup();

   455 }

   456 

   457 // ---------------------------------------------------------------------------

   458 // testOpenDetailsView

   459 // ---------------------------------------------------------------------------

   460 //

   461 void TestMPXVideoPlaybackButtonBar::testOpenDetailsView()

   462 {

   463     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testOpenDetailsView()"));

   464 

   465     init();

   466 

   467     QSignalSpy spy( mButtonBar, SIGNAL( openDetailsView() ) );  

   468 

   469     mController->mViewMode = EFullScreenView;

   470     mButtonBar->mButtons[EMPXButtonDetails]->release();

   471     QVERIFY( mController->mViewMode == EDetailsView );

   472 

   473     mController->mViewMode = EDetailsView;

   474     mButtonBar->mButtons[EMPXButtonDetails]->release();

   475     QVERIFY( mController->mViewMode == EDetailsView );

   476 

   477     mController->mViewMode = EAudioOnlyView;

   478     mButtonBar->mButtons[EMPXButtonDetails]->release();

   479     QVERIFY( mController->mViewMode == EAudioOnlyView );

   480 

   481     cleanup();

   482 }

   483 

   484 // ---------------------------------------------------------------------------

   485 // testAttach

   486 // ---------------------------------------------------------------------------

   487 //

   488 void TestMPXVideoPlaybackButtonBar::testAttach()

   489 {

   490     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackButtonBar::testAttach()"));

   491 

   492     //

   493     // test when 'attach' operation is enabled

   494     //

   495     init( true );

   496 

   497     //

   498     // verify 'attach' button is visible

   499     //

   500     QVERIFY( mButtonBar->mButtons[EMPXButtonAttach]->isVisible() == true );

   501     

   502     //

   503     // release 'attach' button

   504     //

   505     mButtonBar->mButtons[EMPXButtonAttach]->release();

   506 

   507     //

   508     // verify the controller attachVideo() slot has been called

   509     //

   510     QVERIFY( mController->mCommand == EMPXPbvCmdClose );

   511     QVERIFY( mController->mAttachVideoDone == true );

   512     

   513     //

   514     // clean up

   515     //

   516     cleanup();

   517     

   518     //

   519     // test when 'attach' operation is disabled

   520     //

   521     init();

   522 

   523     //

   524     // verify 'attach' button is not visible

   525     //

   526     QVERIFY( mButtonBar->mButtons[EMPXButtonAttach]->isVisible() == false );

   527         

   528     //

   529     // verify the controller attachVideo() slot is not called

   530     //

   531     QVERIFY( mController->mAttachVideoDone == false );

   532     

   533     //

   534     // clean up

   535     //

   536     cleanup();

   537     

   538 }

   539 

   540 // End of file