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 TestMPXVideoPlaybackFileDetailsWidget

    15 * 

    16 */

    17 

    18 // Version : %version:  4 %

    19 

    20 

    21 #include <QDateTime>

    22 #include <QFileInfo>

    23 

    24 #include <hbmainwindow.h>

    25 #include <hbapplication.h>

    26 #include <hblistwidget.h>

    27 #include <hblistwidgetitem.h>

    28 #include <hbextendedlocale.h>

    29 

    30 #include "mpxvideoplaybackviewfiledetails.h"

    31 #include "mpxvideoplaybackcontrolscontroller.h"

    32 #include "testmpxvideoplaybackfiledetailswidget.h"

    33 

    34 #define private public

    35 #include "mpxvideoplaybackfiledetailswidget.h"

    36 #undef private

    37 

    38 const QString KFILEPATH = "C:\\sample1.wav";

    39 

    40 

    41 // ---------------------------------------------------------------------------

    42 // main

    43 // ---------------------------------------------------------------------------

    44 //

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

    46 {

    47     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::Main()"));

    48 

    49     HbApplication app(argc, argv);

    50     HbMainWindow window;

    51 

    52     TestMPXVideoPlaybackFileDetailsWidget tv;

    53 

    54     char *pass[3];

    55     pass[0] = argv[0];

    56     pass[1] = "-o";

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

    58     

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

    60     

    61     return res;

    62 }

    63 

    64 

    65 // ---------------------------------------------------------------------------

    66 // init

    67 // ---------------------------------------------------------------------------

    68 //

    69 void TestMPXVideoPlaybackFileDetailsWidget::init()

    70 {

    71     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::init()"));

    72 

    73     mController = new QMPXVideoPlaybackControlsController();   

    74     mWidget = new QMPXVideoPlaybackFileDetailsWidget( mController );

    75 }

    76 

    77 // ---------------------------------------------------------------------------

    78 // cleanup

    79 // ---------------------------------------------------------------------------

    80 //

    81 void TestMPXVideoPlaybackFileDetailsWidget::cleanup()

    82 {

    83     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::cleanup()"));

    84 

    85     if ( mController )

    86     {

    87         delete mController;

    88         mController = NULL;

    89     }

    90 

    91     if ( mWidget )

    92     {

    93         delete mWidget;

    94         mWidget = NULL;

    95     }

    96 }

    97 

    98 // ---------------------------------------------------------------------------

    99 // testTitle

   100 // ---------------------------------------------------------------------------

   101 //

   102 void TestMPXVideoPlaybackFileDetailsWidget::testTitle()

   103 {

   104     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testTitle()"));

   105 

   106     init();

   107 

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

   109 

   110     //

   111     // For Audio only view

   112     //

   113     mController->mViewMode = EAudioOnlyView;

   114 

   115     // If title information is available

   116     details->mTitle = "Title for Test clip";

   117     mWidget->updateWithFileDetails( details );

   118     verifyResult( "Title", true, details->mTitle );

   119 

   120     mWidget->mListWidget->clear();

   121     mWidget->mFileDetailsUpdated = false;

   122 

   123     // If title informatio is not available

   124     details->mTitle = "";

   125     details->mClipName = KFILEPATH;

   126 

   127     mWidget->updateWithFileDetails( details );

   128     verifyResult( "Title", true, "sample1" );

   129 

   130     mWidget->mListWidget->clear();

   131     mWidget->mFileDetailsUpdated = false;

   132 

   133     //

   134     // For Details view

   135     //

   136     mController->mViewMode = EFullScreenView;

   137 

   138     mWidget->updateWithFileDetails( details );

   139 

   140     verifyResult( "Title", false );

   141 

   142     cleanup();

   143 }

   144 

   145 // ---------------------------------------------------------------------------

   146 // testDescription

   147 // ---------------------------------------------------------------------------

   148 //

   149 void TestMPXVideoPlaybackFileDetailsWidget::testDescription()

   150 {

   151     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testDescription()"));

   152 

   153     init();

   154 

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

   156     details->mDescription = "This is for unit test";

   157     

   158     mWidget->updateWithFileDetails( details );

   159 

   160     verifyResult( "Description", true, details->mDescription );

   161 

   162     cleanup();

   163 }

   164 

   165 // ---------------------------------------------------------------------------

   166 // testDate

   167 // ---------------------------------------------------------------------------

   168 //

   169 void TestMPXVideoPlaybackFileDetailsWidget::testDuration()

   170 {

   171     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testDuration()"));

   172 

   173     init();

   174 

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

   176 

   177     //

   178     // If it's local mode, need to show the duration

   179     //

   180     details->mPlaybackMode = EMPXVideoLocal;

   181     details->mDuration = 3700000;

   182     

   183     mWidget->updateWithFileDetails( details );

   184 

   185     verifyResult( "Duration", true, "1 hr 1 min 40 sec" );

   186 

   187     cleanup();

   188 }

   189 

   190 // ---------------------------------------------------------------------------

   191 // testDate

   192 // ---------------------------------------------------------------------------

   193 //

   194 void TestMPXVideoPlaybackFileDetailsWidget::testDate()

   195 {

   196     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testDate()"));

   197 

   198     init();

   199 

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

   201     

   202     QDateTime dateTime;

   203     QString created("");

   204     QString modified("");

   205     details->mClipName = KFILEPATH;

   206     QFileInfo fileInfo( details->mClipName ); 

   207     

   208     //

   209     // If it is streaming case, we don't show size information

   210     //    

   211     details->mPlaybackMode = EMPXVideoStreaming;

   212     mWidget->updateWithFileDetails( details );

   213 

   214     //

   215     // verify results for streaming clip

   216     //

   217     verifyResult( "Date", false );

   218     verifyResult( "Modified", false );

   219 

   220     //

   221     // clear the widget list

   222     //

   223     mWidget->mListWidget->clear();

   224     mWidget->mFileDetailsUpdated = false;

   225 

   226     //

   227     // local clip, with no date/time metadata

   228     //

   229     details->mPlaybackMode = EMPXVideoLocal;

   230     mWidget->updateWithFileDetails( details );

   231 

   232     //

   233     // compare and verify 'Date' for non-metadata local clip

   234     //

   235     dateTime = fileInfo.created();

   236     created = dateTimeStringFormat( dateTime );

   237     verifyResult( "Date", true, created, true );

   238     

   239     //

   240     // compare and verify 'Modified' for non-metadata local clip

   241     //

   242     dateTime = fileInfo.lastModified();

   243     modified = dateTimeStringFormat( dateTime );

   244     verifyResult( "Modified", true, modified, true );

   245     

   246     //

   247     // clear the widget list

   248     //

   249     mWidget->mListWidget->clear();

   250     mWidget->mFileDetailsUpdated = false;

   251     

   252     //

   253     // local clip, with date/time metadata 

   254     //

   255     details->mPlaybackMode = EMPXVideoLocal;

   256     details->mCreationTime = 1242367251;        // POSIX creation time

   257     details->mModificationTime = 1270773249;    // POSIX modification time    

   258     mWidget->updateWithFileDetails( details );

   259 

   260     //

   261     // compare and verify 'Date' for metadata local clip

   262     //

   263     dateTime.setTime_t( details->mCreationTime );

   264     created = dateTimeStringFormat( dateTime );

   265     verifyResult( "Date", true, created, true );

   266     

   267     //

   268     // compare and verify 'Modified' for metadata local clip

   269     //

   270     dateTime.setTime_t( details->mModificationTime ); 

   271     modified = dateTimeStringFormat( dateTime );

   272     verifyResult( "Modified", true, modified, true );

   273 

   274     //

   275     // clean up

   276     //

   277     cleanup();

   278 }

   279 

   280 // ---------------------------------------------------------------------------

   281 // testLocation

   282 // ---------------------------------------------------------------------------

   283 //

   284 void TestMPXVideoPlaybackFileDetailsWidget::testLocation()

   285 {

   286     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testLocation()"));

   287 

   288     init();

   289 

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

   291     details->mLocation = "C:\\data\\Videos\\";

   292     

   293     mWidget->updateWithFileDetails( details );

   294 

   295     verifyResult( "Location", true, details->mLocation );

   296 

   297     cleanup();

   298 }

   299 

   300 // ---------------------------------------------------------------------------

   301 // testAuthor

   302 // ---------------------------------------------------------------------------

   303 //

   304 void TestMPXVideoPlaybackFileDetailsWidget::testAuthor()

   305 {

   306     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testAuthor()"));

   307 

   308     init();

   309 

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

   311     details->mArtist = "Fusion";

   312     

   313     mWidget->updateWithFileDetails( details );

   314 

   315     verifyResult( "Author", true, details->mArtist );

   316 

   317     cleanup();

   318 }

   319 

   320 // ---------------------------------------------------------------------------

   321 // testCopyright

   322 // ---------------------------------------------------------------------------

   323 //

   324 void TestMPXVideoPlaybackFileDetailsWidget::testCopyright()

   325 {

   326     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testCopyright()"));

   327 

   328     init();

   329 

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

   331     details->mCopyright = "Fusion team";

   332     

   333     mWidget->updateWithFileDetails( details );

   334 

   335     verifyResult( "Copyright", true, details->mCopyright );

   336 

   337     cleanup();

   338 }

   339 

   340 // ---------------------------------------------------------------------------

   341 // testLanguage

   342 // ---------------------------------------------------------------------------

   343 //

   344 void TestMPXVideoPlaybackFileDetailsWidget::testLanguage()

   345 {

   346     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testLanguage()"));

   347 

   348     init();

   349 

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

   351     details->mLanguage = "English";

   352     

   353     mWidget->updateWithFileDetails( details );

   354 

   355     verifyResult( "Language", true, details->mLanguage );

   356 

   357     cleanup();

   358 }

   359 

   360 // ---------------------------------------------------------------------------

   361 // testKeywords

   362 // ---------------------------------------------------------------------------

   363 //

   364 void TestMPXVideoPlaybackFileDetailsWidget::testKeywords()

   365 {

   366     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testKeywords()"));

   367 

   368     init();

   369 

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

   371     details->mKeywords = "QTest";

   372     

   373     mWidget->updateWithFileDetails( details );

   374 

   375     verifyResult( "Keywords", true, details->mKeywords );

   376 

   377     cleanup();

   378 }

   379 

   380 // ---------------------------------------------------------------------------

   381 // testSize

   382 // ---------------------------------------------------------------------------

   383 //

   384 void TestMPXVideoPlaybackFileDetailsWidget::testSize()

   385 {

   386     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testSize()"));

   387 

   388     init();

   389 

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

   391 

   392     //

   393     // If it is streaming case, we don't show size information

   394     //

   395     details->mPlaybackMode = EMPXVideoStreaming;

   396     details->mClipName = KFILEPATH;

   397 

   398     mWidget->updateWithFileDetails( details );

   399 

   400     verifyResult( "Size", false );

   401 

   402     mWidget->mListWidget->clear();

   403     mWidget->mFileDetailsUpdated = false;

   404 

   405     //

   406     // If it is local, we show size information

   407     //

   408     details->mPlaybackMode = EMPXVideoLocal;

   409     mWidget->updateWithFileDetails( details );

   410     

   411     verifyResult( "Size", true, "", false );

   412 

   413     cleanup();

   414 }

   415 

   416 // ---------------------------------------------------------------------------

   417 // testResolution

   418 // ---------------------------------------------------------------------------

   419 //

   420 void TestMPXVideoPlaybackFileDetailsWidget::testResolution()

   421 {

   422     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testResolution()"));

   423 

   424     init();

   425 

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

   427 

   428     //

   429     // If it is audio only clip, don't need to show resolution

   430     //

   431     details->mVideoEnabled = false;

   432     

   433     mWidget->updateWithFileDetails( details );

   434 

   435     verifyResult( "Resolution", false );

   436 

   437     mWidget->mListWidget->clear();

   438     mWidget->mFileDetailsUpdated = false;

   439 

   440     //

   441     // If it has video track

   442     //

   443     details->mVideoEnabled = true;

   444     details->mVideoWidth = 640;

   445     details->mVideoHeight = 360;

   446 

   447     mWidget->updateWithFileDetails( details );

   448 

   449     QString resolution = QString("%1x%2")

   450             .arg( details->mVideoWidth ).arg( details->mVideoHeight );

   451 

   452     verifyResult( "Resolution", true, resolution );

   453 

   454     cleanup();

   455 }

   456 

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

   458 // testFormat

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

   460 //

   461 void TestMPXVideoPlaybackFileDetailsWidget::testFormat()

   462 {

   463     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testFormat()"));

   464 

   465     init();

   466 

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

   468     details->mMimeType = "Nothing";

   469     

   470     mWidget->updateWithFileDetails( details );

   471 

   472     verifyResult( "Format", true, details->mMimeType );

   473 

   474     cleanup();

   475 }

   476 

   477 // ---------------------------------------------------------------------------

   478 // testBitrate

   479 // ---------------------------------------------------------------------------

   480 //

   481 void TestMPXVideoPlaybackFileDetailsWidget::testBitrate()

   482 {

   483     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testBitrate()"));

   484 

   485 

   486     init();

   487 

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

   489     details->mBitRate = 512;

   490     

   491     mWidget->updateWithFileDetails( details );

   492 

   493     verifyResult( "Bitrate", true, "512 kbps" );

   494 

   495     cleanup();

   496 }

   497 

   498 // ---------------------------------------------------------------------------

   499 // testFolder

   500 // ---------------------------------------------------------------------------

   501 //

   502 void TestMPXVideoPlaybackFileDetailsWidget::testFolder()

   503 {

   504     MPX_ENTER_EXIT(_L("TestMPXVideoPlaybackFileDetailsWidget::testFolder()"));

   505 

   506     init();

   507 

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

   509 

   510     //

   511     // If it is streaming case, we don't show folder information

   512     //

   513     details->mPlaybackMode = EMPXVideoStreaming;

   514     details->mClipName = KFILEPATH;

   515     

   516     mWidget->updateWithFileDetails( details );

   517 

   518     verifyResult( "Collection", false );

   519 

   520     mWidget->mListWidget->clear();

   521     mWidget->mFileDetailsUpdated = false;

   522 

   523     //

   524     // If it is local case, we show folder information

   525     //

   526     details->mPlaybackMode = EMPXVideoLocal;

   527 

   528     mWidget->updateWithFileDetails( details );

   529 

   530     verifyResult( "Collection", false );

   531 

   532     cleanup();

   533 

   534 }

   535 

   536 // ---------------------------------------------------------------------------

   537 // verifyResult

   538 // ---------------------------------------------------------------------------

   539 //

   540 void TestMPXVideoPlaybackFileDetailsWidget::verifyResult( 

   541         QString primaryText, bool exist, QString expectedSecondaryText, bool needToBeCompared )

   542 {

   543     MPX_DEBUG(_L("TestMPXVideoPlaybackFileDetailsWidget::verifyResult(%s, %d, %s, %d)"),

   544             primaryText.data(), exist, expectedSecondaryText.data(), needToBeCompared );

   545     

   546     QString secondaryText = "";

   547     int i = 0;

   548 

   549     for( ; i < mWidget->mListWidget->count() ; i++ )

   550     {

   551         HbListWidgetItem *item = mWidget->mListWidget->item( i );

   552 

   553         if ( item->text() == primaryText )

   554         {

   555             secondaryText = item->secondaryText();

   556             break;

   557         }

   558     }

   559 

   560     //

   561     // If the item needs to be existed in HbListWidget, check the result

   562     //

   563     if ( exist )

   564     {

   565         if ( needToBeCompared )

   566         {

   567             MPX_DEBUG(_L("TestMPXVideoPlaybackFileDetailsWidget::verifyResult() : secondaryText(%s)"),

   568                     secondaryText.data() );

   569             

   570             QVERIFY( expectedSecondaryText == secondaryText );

   571         }

   572         else

   573         {

   574             MPX_DEBUG(_L("TestMPXVideoPlaybackFileDetailsWidget::verifyResult() : i(%d) count(%d)"),

   575                     i, mWidget->mListWidget->count() );

   576             

   577             //

   578             // Doens't need to compare the secondary text. Just make sure it's in the list

   579             //

   580             QVERIFY( i < mWidget->mListWidget->count() );

   581         }

   582 

   583     }

   584     //

   585     // If not, just make sure that item is not in the list

   586     //

   587     else

   588     {

   589         QVERIFY( i == mWidget->mListWidget->count() );

   590     }

   591 }

   592 

   593 

   594 // -------------------------------------------------------------------------------------------------

   595 // dateTimeStringFormat

   596 // -------------------------------------------------------------------------------------------------

   597 //

   598 QString TestMPXVideoPlaybackFileDetailsWidget::dateTimeStringFormat( QDateTime dateTime )

   599 {

   600     HbExtendedLocale locale = HbExtendedLocale::system();

   601     QString date = locale.format( dateTime.date(), r_qtn_date_usual );

   602     QString time = locale.format( dateTime.time(), r_qtn_time_long_with_zero );

   603     QString dateTimeString( date + "  " + time );

   604     

   605     MPX_DEBUG(_L("TestMPXVideoPlaybackFileDetailsWidget::dateTimeStringFormat() ret '%s'"),

   606             dateTimeString.data() );

   607     

   608     return dateTimeString;    

   609 }

   610 

   611 // End of file