videocollection/videocollectionview/tsrc/testvideocollectionuiloader/src/testvideocollectionuiloader.cpp
changeset 36 8aed59de29f9
child 24 7d93ee07fb27
equal deleted inserted replaced
35:3738fe97f027 36:8aed59de29f9
       
     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 VideoCollectionUiLoader
       
    15 *
       
    16 */
       
    17 
       
    18 #include <hbdocumentloader.h>
       
    19 #include <hbgroupbox.h>
       
    20 #include <hbaction.h>
       
    21 #include <hbapplication.h>
       
    22 #include <hbmainwindow.h>
       
    23 #include <hbinstance.h>
       
    24 #include <hbview.h>
       
    25 #include <qhash.h>
       
    26 #include <qmap.h>
       
    27 #include <qset.h>
       
    28 #include <qdebug.h>
       
    29 
       
    30 #include "testvideocollectionuiloader.h"
       
    31 #include "videohintwidget.h"
       
    32 #include "videocollectionwrapperdata.h"
       
    33 
       
    34 #define private public
       
    35 #include "videocollectionuiloader.h"
       
    36 #include "videocollectionuiloaderdef.h"
       
    37 #undef private
       
    38 
       
    39 int main(int argc, char *argv[])
       
    40 {
       
    41     HbApplication app(argc, argv);
       
    42     HbMainWindow window;
       
    43     TestVideoCollectionUiLoader tv;
       
    44     int res;
       
    45     if (argc > 1)
       
    46     {   
       
    47         res = QTest::qExec(&tv, argc, argv);
       
    48     }
       
    49     else
       
    50     {
       
    51         char *pass[3];
       
    52         pass[0] = argv[0];
       
    53         pass[1] = "-o";
       
    54         pass[2] = "c:\\data\\testvideocollectionuiloader.txt";
       
    55         res = QTest::qExec(&tv, 3, pass);
       
    56     }
       
    57     
       
    58     return res;
       
    59 }
       
    60 
       
    61 TestVideoCollectionUiLoader::TestVideoCollectionUiLoader():
       
    62     mTestObject(0)
       
    63 {
       
    64     
       
    65 }
       
    66 
       
    67 TestVideoCollectionUiLoader::~TestVideoCollectionUiLoader()
       
    68 {
       
    69     cleanup();
       
    70 }
       
    71 
       
    72 // ---------------------------------------------------------------------------
       
    73 // init
       
    74 // ---------------------------------------------------------------------------
       
    75 //
       
    76 void TestVideoCollectionUiLoader::init()
       
    77 {
       
    78     // create test object
       
    79     if (!mTestObject)
       
    80     {
       
    81         mTestObject = new VideoCollectionUiLoader;
       
    82     }
       
    83     
       
    84     // clear object list
       
    85     mObjects.clear();
       
    86     
       
    87     HbDocumentLoader::cleanup();
       
    88 }
       
    89 
       
    90 // ---------------------------------------------------------------------------
       
    91 // cleanup
       
    92 // ---------------------------------------------------------------------------
       
    93 //
       
    94 void TestVideoCollectionUiLoader::cleanup()
       
    95 {
       
    96     // delete test object
       
    97     delete mTestObject;
       
    98     mTestObject = 0;
       
    99 }
       
   100 
       
   101 // TEST CASES START ----------------------------------------------------------
       
   102 
       
   103 // ---------------------------------------------------------------------------
       
   104 // testAddData
       
   105 // ---------------------------------------------------------------------------
       
   106 //
       
   107 void TestVideoCollectionUiLoader::testAddData()
       
   108 {
       
   109     VideoCollectionUiLoaderParam banner(
       
   110         DOCML_NAME_VC_HEADINGBANNER,
       
   111         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   112         true,
       
   113         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   114     VideoCollectionUiLoaderParam collectionWidget(
       
   115         DOCML_NAME_VC_COLLECTIONWIDGET,
       
   116         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   117         DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST,
       
   118         true,
       
   119         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   120     VideoCollectionUiLoaderParam collectionContentWidget(
       
   121         DOCML_NAME_VC_COLLECTIONCONTENTWIDGET,
       
   122         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   123         DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST,
       
   124         true,
       
   125         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   126     const int COUNT = 3;
       
   127     
       
   128     // add items
       
   129     QList<VideoCollectionUiLoaderParam> params;
       
   130     params.append(banner);
       
   131     params.append(collectionWidget);
       
   132     params.append(collectionContentWidget);
       
   133     mTestObject->addData(params,
       
   134         this,
       
   135         SLOT(handleObjectReady(QObject*, const QString&)));
       
   136     QVERIFY(mTestObject->mQueue.count() == COUNT);
       
   137     QVERIFY(mTestObject->mQueue.contains(banner));
       
   138     QVERIFY(mTestObject->mQueue.contains(collectionWidget));
       
   139     QVERIFY(mTestObject->mQueue.contains(collectionContentWidget));
       
   140     
       
   141     // add duplicate items
       
   142     mTestObject->addData(params,
       
   143         this,
       
   144         SLOT(handleObjectReady(QObject*, const QString&)));
       
   145     QVERIFY(mTestObject->mQueue.count() == COUNT);
       
   146     QVERIFY(mTestObject->mQueue.contains(banner));
       
   147     QVERIFY(mTestObject->mQueue.contains(collectionWidget));
       
   148     QVERIFY(mTestObject->mQueue.contains(collectionContentWidget));
       
   149     
       
   150     // load first phase and add duplicate items
       
   151     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   152     QTest::qWait(1000); // wait 1 second
       
   153     mTestObject->addData(params,
       
   154         this,
       
   155         SLOT(handleObjectReady(QObject*, const QString&)));
       
   156     QCOMPARE(mTestObject->mQueue.count(), 0);
       
   157 }
       
   158 
       
   159 // ---------------------------------------------------------------------------
       
   160 // testFindWidget
       
   161 // ---------------------------------------------------------------------------
       
   162 //
       
   163 void TestVideoCollectionUiLoader::testFindWidget()
       
   164 {
       
   165     HbDocumentLoader::cleanup();
       
   166     
       
   167     QList<VideoCollectionUiLoaderParam> params;
       
   168     VideoCollectionUiLoaderParam banner(
       
   169         DOCML_NAME_VC_HEADINGBANNER,
       
   170         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   171         true,
       
   172         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   173     VideoCollectionUiLoaderParam hint(
       
   174         DOCML_NAME_VC_VIDEOHINTWIDGET,
       
   175         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   176         DOCML_VIDEOCOLLECTIONVIEW_SECTION_HINT,
       
   177         true,
       
   178         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   179     
       
   180     // pre-load widget asynchronously and find widget
       
   181     params.append(banner);
       
   182     mTestObject->addData(params,
       
   183         this,
       
   184         SLOT(handleObjectReady(QObject*, const QString&)));
       
   185     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   186     QTest::qWait(1000); // wait 1 second
       
   187     HbGroupBox *bannerWidget =
       
   188         mTestObject->findWidget<HbGroupBox>(
       
   189             DOCML_NAME_VC_HEADINGBANNER);
       
   190     QVERIFY(bannerWidget);
       
   191     QVERIFY(mObjects.contains(DOCML_NAME_VC_HEADINGBANNER));
       
   192     params.clear();
       
   193     cleanup();
       
   194     init();
       
   195 
       
   196     // do not pre-load widget and load it, docml not loaded
       
   197     HbDocumentLoader::mFindWidgetFails = true;
       
   198     bannerWidget =
       
   199         mTestObject->findWidget<HbGroupBox>(
       
   200             DOCML_NAME_VC_HEADINGBANNER);
       
   201     QVERIFY(!bannerWidget);
       
   202     QVERIFY(!mObjects.contains(DOCML_NAME_VC_HEADINGBANNER));
       
   203     cleanup();
       
   204     init();
       
   205 
       
   206     // do not pre-load widget but add it in queue, docml loaded
       
   207     bool ok = false;
       
   208     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   209     QVERIFY(ok);
       
   210     params.append(banner);
       
   211     mTestObject->addData(params,
       
   212         this,
       
   213         SLOT(handleObjectReady(QObject*, const QString&)));
       
   214     bannerWidget =
       
   215         mTestObject->findWidget<HbGroupBox>(
       
   216             DOCML_NAME_VC_HEADINGBANNER);
       
   217     QVERIFY(bannerWidget);
       
   218     QVERIFY(mObjects.contains(DOCML_NAME_VC_HEADINGBANNER));
       
   219     params.clear();
       
   220     cleanup();
       
   221     init();
       
   222 
       
   223     // do not pre-load widget, docml loaded
       
   224     ok = false;
       
   225     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   226     QVERIFY(ok);
       
   227     bannerWidget =
       
   228         mTestObject->findWidget<HbGroupBox>(
       
   229             DOCML_NAME_VC_HEADINGBANNER);
       
   230     QVERIFY(bannerWidget);
       
   231     QVERIFY(!mObjects.contains(DOCML_NAME_VC_HEADINGBANNER));
       
   232     cleanup();
       
   233     init();
       
   234 
       
   235     // do not pre-load widget but add it in queue, section loaded
       
   236     ok = false;
       
   237     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   238     QVERIFY(ok);
       
   239     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   240         DOCML_VIDEOCOLLECTIONVIEW_SECTION_HINT,
       
   241         &ok);
       
   242     QVERIFY(ok);
       
   243     params.append(hint);
       
   244     mTestObject->addData(params,
       
   245         this,
       
   246         SLOT(handleObjectReady(QObject*, const QString&)));
       
   247     VideoHintWidget *hintWidget =
       
   248         mTestObject->findWidget<VideoHintWidget>(
       
   249             DOCML_NAME_VC_VIDEOHINTWIDGET);
       
   250     QVERIFY(hintWidget);
       
   251     QVERIFY(mObjects.contains(DOCML_NAME_VC_VIDEOHINTWIDGET));
       
   252     params.clear();
       
   253     cleanup();
       
   254     init();
       
   255 
       
   256     // do not pre-load widget, section not loaded
       
   257     ok = false;
       
   258     HbDocumentLoader::mFindWidgetFails = true;
       
   259     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   260     QVERIFY(ok);
       
   261     hintWidget =
       
   262         mTestObject->findWidget<VideoHintWidget>(
       
   263             DOCML_NAME_VC_VIDEOHINTWIDGET);
       
   264     QVERIFY(!hintWidget);
       
   265     QVERIFY(!mObjects.contains(DOCML_NAME_VC_VIDEOHINTWIDGET));
       
   266 }
       
   267 
       
   268 // ---------------------------------------------------------------------------
       
   269 // testFindObject
       
   270 // ---------------------------------------------------------------------------
       
   271 //
       
   272 void TestVideoCollectionUiLoader::testFindObject()
       
   273 {
       
   274     HbDocumentLoader::cleanup();
       
   275     
       
   276     QList<VideoCollectionUiLoaderParam> params;
       
   277     VideoCollectionUiLoaderParam addToCollectionParam(
       
   278         DOCML_NAME_ADD_TO_COLLECTION,
       
   279         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   280         false,
       
   281         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   282     
       
   283     // find object:
       
   284     // -docml not loaded
       
   285     // -object not added in loading queue
       
   286     HbDocumentLoader::mFindObjectFails = true;
       
   287     HbAction *addToCollection = mTestObject->findObject<HbAction>(DOCML_NAME_ADD_TO_COLLECTION);
       
   288     QVERIFY(!addToCollection);
       
   289     QVERIFY(!mObjects.contains(DOCML_NAME_ADD_TO_COLLECTION));
       
   290     cleanup();
       
   291     init();
       
   292 
       
   293     // find object:
       
   294     // -docml not loaded
       
   295     // -object added in loading queue
       
   296     params.append(addToCollectionParam);
       
   297     mTestObject->addData(params, this, SLOT(handleObjectReady(QObject*, const QString&)));
       
   298     addToCollection = mTestObject->findObject<HbAction>(DOCML_NAME_ADD_TO_COLLECTION);
       
   299     QVERIFY(addToCollection);
       
   300     QVERIFY(mObjects.contains(DOCML_NAME_ADD_TO_COLLECTION));
       
   301     params.clear();
       
   302     cleanup();
       
   303     init();
       
   304 
       
   305     // find object:
       
   306     // -docml loaded
       
   307     // -object not added in loading queue
       
   308     bool ok = false;
       
   309     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   310     QVERIFY(ok);
       
   311     addToCollection = mTestObject->findObject<HbAction>(DOCML_NAME_ADD_TO_COLLECTION);
       
   312     QVERIFY(addToCollection);
       
   313     QVERIFY(!mObjects.contains(DOCML_NAME_ADD_TO_COLLECTION));
       
   314     cleanup();
       
   315     init();
       
   316 
       
   317     // find object:
       
   318     // -docml loaded
       
   319     // -object added in loading queue
       
   320     ok = false;
       
   321     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   322     QVERIFY(ok);
       
   323     params.append(addToCollectionParam);
       
   324     mTestObject->addData(params, this, SLOT(handleObjectReady(QObject*, const QString&)));
       
   325     addToCollection = mTestObject->findObject<HbAction>(DOCML_NAME_ADD_TO_COLLECTION);
       
   326     QVERIFY(addToCollection);
       
   327     QVERIFY(mObjects.contains(DOCML_NAME_ADD_TO_COLLECTION));
       
   328     params.clear();
       
   329 }
       
   330 
       
   331 // ---------------------------------------------------------------------------
       
   332 // testIsService
       
   333 // ---------------------------------------------------------------------------
       
   334 //
       
   335 void TestVideoCollectionUiLoader::testIsService()
       
   336 {
       
   337     // is service:
       
   338     // -service flag set
       
   339     mTestObject->setIsService(true);
       
   340     QVERIFY(mTestObject->mIsService);
       
   341     cleanup();
       
   342     init();
       
   343     
       
   344     // is service:
       
   345     // -service flag not set    
       
   346     mTestObject->setIsService(false);
       
   347     QVERIFY(!mTestObject->mIsService);
       
   348 }
       
   349 
       
   350 // ---------------------------------------------------------------------------
       
   351 // testLoadDocml
       
   352 // ---------------------------------------------------------------------------
       
   353 //
       
   354 void TestVideoCollectionUiLoader::testLoadDocml()
       
   355 {
       
   356     HbDocumentLoader::mLoadReturns.append(new QObject());
       
   357     
       
   358     // load docml:
       
   359     // -correct docml once
       
   360     bool ok = false;
       
   361     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   362     QVERIFY(ok);
       
   363     QVERIFY(mTestObject->mDocmls.contains(DOCML_VIDEOCOLLECTIONVIEW_FILE));
       
   364     cleanup();
       
   365     init();
       
   366     
       
   367     // load docml:
       
   368     // -two correct docmls
       
   369     ok = false;
       
   370     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   371     QVERIFY(ok);
       
   372     QVERIFY(mTestObject->mDocmls.contains(DOCML_VIDEOCOLLECTIONVIEW_FILE));
       
   373     mTestObject->load(DOCML_VIDEOSELECTIONDIALOG_FILE, &ok);
       
   374     QVERIFY(ok);
       
   375     QVERIFY(mTestObject->mDocmls.contains(DOCML_VIDEOSELECTIONDIALOG_FILE));
       
   376     cleanup();
       
   377     init();
       
   378 
       
   379     // load docml:
       
   380     // -same docml twice
       
   381     ok = false;
       
   382     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   383     QVERIFY(ok);
       
   384     QVERIFY(mTestObject->mDocmls.contains(DOCML_VIDEOCOLLECTIONVIEW_FILE));
       
   385     int objectCount = mTestObject->mOrphans.count();
       
   386     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   387     QVERIFY(ok);
       
   388     QVERIFY(mTestObject->mDocmls.contains(DOCML_VIDEOCOLLECTIONVIEW_FILE));
       
   389     QVERIFY(objectCount == mTestObject->mOrphans.count());
       
   390     cleanup();
       
   391     init();
       
   392 
       
   393     // load docml:
       
   394     // -incorrect docml
       
   395     const char *INVALID_DOCML = "invalid docml";
       
   396     ok = false;
       
   397     HbDocumentLoader::mLoadFails = true;
       
   398     mTestObject->load(INVALID_DOCML, &ok);
       
   399     QVERIFY(!ok);
       
   400     QVERIFY(!mTestObject->mDocmls.contains(INVALID_DOCML));
       
   401 }
       
   402 
       
   403 // ---------------------------------------------------------------------------
       
   404 // testLoadSection
       
   405 // ---------------------------------------------------------------------------
       
   406 //
       
   407 void TestVideoCollectionUiLoader::testLoadSection()
       
   408 {
       
   409     HbDocumentLoader::cleanup();
       
   410     
       
   411     // load section:
       
   412     // -docml loaded
       
   413     // -correct section once
       
   414     bool ok = false;
       
   415     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   416     QVERIFY(ok);
       
   417     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST, &ok);
       
   418     QVERIFY(ok);
       
   419     QVERIFY(mTestObject->mSections.contains(DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST));
       
   420     cleanup();
       
   421     init();
       
   422 
       
   423     // load section:
       
   424     // -docml loaded
       
   425     // -two correct sections
       
   426     ok = false;
       
   427     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   428     QVERIFY(ok);
       
   429     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST, &ok);
       
   430     QVERIFY(ok);
       
   431     QVERIFY(mTestObject->mSections.contains(DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST));
       
   432     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, DOCML_VIDEOCOLLECTIONVIEW_SECTION_HINT, &ok);
       
   433     QVERIFY(ok);
       
   434     QVERIFY(mTestObject->mSections.contains(DOCML_VIDEOCOLLECTIONVIEW_SECTION_HINT));
       
   435     cleanup();
       
   436     init();
       
   437 
       
   438     // load section:
       
   439     // -docml loaded
       
   440     // -same section twice
       
   441     ok = false;
       
   442     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   443     QVERIFY(ok);
       
   444     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST, &ok);
       
   445     QVERIFY(ok);
       
   446     QVERIFY(mTestObject->mSections.contains(DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST));
       
   447     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST, &ok);
       
   448     int sectionCount = mTestObject->mSections.count();
       
   449     QVERIFY(ok);
       
   450     QVERIFY(mTestObject->mSections.contains(DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST));
       
   451     QVERIFY(sectionCount == mTestObject->mSections.count());
       
   452     cleanup();
       
   453     init();
       
   454 
       
   455     // load section:
       
   456     // -docml not loaded
       
   457     // -correct section once
       
   458     ok = false;
       
   459     HbDocumentLoader::mLoadFails = true;
       
   460     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST, &ok);
       
   461     QVERIFY(!ok);
       
   462     QVERIFY(!mTestObject->mSections.contains(DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST));
       
   463     cleanup();
       
   464     init();
       
   465 }
       
   466 
       
   467 // ---------------------------------------------------------------------------
       
   468 // testLoadPhase
       
   469 // ---------------------------------------------------------------------------
       
   470 //
       
   471 void TestVideoCollectionUiLoader::testLoadPhase()
       
   472 {
       
   473     HbDocumentLoader::cleanup();
       
   474     
       
   475     // load phase:
       
   476     // -add first phase items in queue
       
   477     // -load first phase
       
   478     VideoCollectionUiLoaderParam videoWidgetParam(
       
   479         DOCML_NAME_VC_VIDEOLISTWIDGET,
       
   480         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   481         true,
       
   482         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   483     VideoCollectionUiLoaderParam collectionWidgetParam(
       
   484         DOCML_NAME_VC_COLLECTIONWIDGET,
       
   485         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   486         DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST,
       
   487         true,
       
   488         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   489     VideoCollectionUiLoaderParam collectionContentWidgetParam(
       
   490         DOCML_NAME_VC_COLLECTIONCONTENTWIDGET,
       
   491         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   492         DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST,
       
   493         true,
       
   494         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   495     QList<VideoCollectionUiLoaderParam> params;
       
   496     params.append(videoWidgetParam);
       
   497     params.append(collectionWidgetParam);
       
   498     params.append(collectionContentWidgetParam);
       
   499     mTestObject->addData(params,
       
   500         this,
       
   501         SLOT(handleObjectReady(QObject*, const QString&)));
       
   502     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   503     QTest::qWait(1000); // wait 1 second
       
   504     QVERIFY(mTestObject->mPhases.contains(VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   505     QCOMPARE(mTestObject->mObjects.count(), 3);
       
   506     QVERIFY(mTestObject->mObjects.contains(DOCML_NAME_VC_VIDEOLISTWIDGET));
       
   507     QVERIFY(mTestObject->mObjects.contains(DOCML_NAME_VC_COLLECTIONWIDGET));
       
   508     QVERIFY(mTestObject->mObjects.contains(DOCML_NAME_VC_COLLECTIONCONTENTWIDGET));
       
   509     params.clear();
       
   510     cleanup();
       
   511     init();
       
   512 
       
   513     // load phase:
       
   514     // -add second phase items in queue
       
   515     // -load first phase
       
   516     // -load second phase
       
   517     VideoCollectionUiLoaderParam addToCollectionParam(
       
   518         DOCML_NAME_ADD_TO_COLLECTION,
       
   519         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   520         false,
       
   521         VideoCollectionUiLoaderParam::LoadPhaseSecondary);
       
   522     VideoCollectionUiLoaderParam createCollectionParam(
       
   523         DOCML_NAME_CREATE_COLLECTION,
       
   524         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   525         false,
       
   526         VideoCollectionUiLoaderParam::LoadPhaseSecondary);
       
   527     VideoCollectionUiLoaderParam deleteMultipleParam(
       
   528         DOCML_NAME_DELETE_MULTIPLE,
       
   529         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   530         false,
       
   531         VideoCollectionUiLoaderParam::LoadPhaseSecondary);
       
   532     params.append(addToCollectionParam);
       
   533     params.append(createCollectionParam);
       
   534     params.append(deleteMultipleParam);
       
   535     mTestObject->addData(params,
       
   536         this,
       
   537         SLOT(handleObjectReady(QObject*, const QString&)));
       
   538     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   539     QTest::qWait(1000); // wait 1 second
       
   540     QVERIFY(mTestObject->mPhases.contains(VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   541     QVERIFY(mTestObject->mObjects.count() == 0);
       
   542     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhaseSecondary);
       
   543     QTest::qWait(1000); // wait 1 second
       
   544     QVERIFY(mTestObject->mPhases.contains(VideoCollectionUiLoaderParam::LoadPhaseSecondary));
       
   545     QCOMPARE(mTestObject->mObjects.count(), 3);
       
   546     QVERIFY(mTestObject->mObjects.contains(DOCML_NAME_ADD_TO_COLLECTION));
       
   547     QVERIFY(mTestObject->mObjects.contains(DOCML_NAME_CREATE_COLLECTION));
       
   548     QVERIFY(mTestObject->mObjects.contains(DOCML_NAME_DELETE_MULTIPLE));
       
   549     params.clear();
       
   550     cleanup();
       
   551     init();
       
   552 
       
   553     // load phase:
       
   554     // -add first phase items in queue
       
   555     // -add second phase items in queue
       
   556     // -load first phase
       
   557     // -load second phase
       
   558     params.append(videoWidgetParam);
       
   559     params.append(addToCollectionParam);
       
   560     mTestObject->addData(params,
       
   561         this,
       
   562         SLOT(handleObjectReady(QObject*, const QString&)));
       
   563     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   564     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhaseSecondary);
       
   565     QTest::qWait(1000); // wait 1 second
       
   566     QVERIFY(mTestObject->mPhases.contains(VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   567     QVERIFY(mTestObject->mPhases.contains(VideoCollectionUiLoaderParam::LoadPhaseSecondary));
       
   568     QCOMPARE(mTestObject->mObjects.count(), 2);
       
   569     QVERIFY(mTestObject->mObjects.contains(DOCML_NAME_VC_VIDEOLISTWIDGET));
       
   570     QVERIFY(mTestObject->mObjects.contains(DOCML_NAME_ADD_TO_COLLECTION));
       
   571     params.clear();
       
   572     cleanup();
       
   573     init();
       
   574 }
       
   575 
       
   576 // ---------------------------------------------------------------------------
       
   577 // testLoadPhase_2
       
   578 // ---------------------------------------------------------------------------
       
   579 //
       
   580 void TestVideoCollectionUiLoader::testLoadPhase_2()
       
   581 {
       
   582     // load phase:
       
   583     // -add all items
       
   584     // -load all items
       
   585     QList<VideoCollectionUiLoaderParam> params;
       
   586     params.append(VideoCollectionUiLoaderParam(
       
   587         DOCML_NAME_VIEW,
       
   588         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   589         true,
       
   590         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   591     params.append(VideoCollectionUiLoaderParam(
       
   592         DOCML_NAME_VC_HEADINGBANNER,
       
   593         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   594         true,
       
   595         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   596     params.append(VideoCollectionUiLoaderParam(
       
   597         DOCML_NAME_VC_COLLECTIONWIDGET,
       
   598         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   599         DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST,
       
   600         true,
       
   601         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   602     params.append(VideoCollectionUiLoaderParam(
       
   603         DOCML_NAME_VC_COLLECTIONCONTENTWIDGET,
       
   604         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   605         DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST,
       
   606         true,
       
   607         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   608     params.append(VideoCollectionUiLoaderParam(
       
   609         DOCML_NAME_VC_VIDEOLISTWIDGET,
       
   610         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   611         true,
       
   612         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   613     params.append(VideoCollectionUiLoaderParam(
       
   614         DOCML_NAME_VC_VIDEOHINTWIDGET,
       
   615         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   616         DOCML_VIDEOCOLLECTIONVIEW_SECTION_HINT,
       
   617         true,
       
   618         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   619     params.append(VideoCollectionUiLoaderParam(
       
   620         DOCML_NAME_OPTIONS_MENU,
       
   621         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   622         true,
       
   623         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   624     params.append(VideoCollectionUiLoaderParam(
       
   625         DOCML_NAME_SORT_MENU,
       
   626         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   627         true,
       
   628         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   629     params.append(VideoCollectionUiLoaderParam(
       
   630         DOCML_NAME_SORT_BY_DATE,
       
   631         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   632         false,
       
   633         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   634     params.append(VideoCollectionUiLoaderParam(
       
   635         DOCML_NAME_SORT_BY_NAME,
       
   636         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   637         false,
       
   638         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   639     params.append(VideoCollectionUiLoaderParam(
       
   640         DOCML_NAME_SORT_BY_NUMBER_OF_ITEMS,
       
   641         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   642         false,
       
   643         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   644     params.append(VideoCollectionUiLoaderParam(
       
   645         DOCML_NAME_SORT_BY_SIZE,
       
   646         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   647         false,
       
   648         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   649     params.append(VideoCollectionUiLoaderParam(
       
   650         DOCML_NAME_ADD_TO_COLLECTION,
       
   651         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   652         false,
       
   653         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   654     params.append(VideoCollectionUiLoaderParam(
       
   655         DOCML_NAME_CREATE_COLLECTION,
       
   656         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   657         false,
       
   658         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   659     params.append(VideoCollectionUiLoaderParam(
       
   660         DOCML_NAME_DELETE_MULTIPLE,
       
   661         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   662         false,
       
   663         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   664     params.append(VideoCollectionUiLoaderParam(
       
   665         DOCML_NAME_HINT_BUTTON,
       
   666         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   667         DOCML_VIDEOCOLLECTIONVIEW_SECTION_HINT,
       
   668         true,
       
   669         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   670     params.append(VideoCollectionUiLoaderParam(
       
   671         DOCML_NAME_HINT_LABEL,
       
   672         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   673         DOCML_VIDEOCOLLECTIONVIEW_SECTION_HINT,
       
   674         true,
       
   675         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   676     params.append(VideoCollectionUiLoaderParam(
       
   677         DOCML_NAME_NO_VIDEOS_LABEL,
       
   678         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   679         DOCML_VIDEOCOLLECTIONVIEW_SECTION_HINT,
       
   680         true,
       
   681         VideoCollectionUiLoaderParam::LoadPhasePrimary));
       
   682     params.append(VideoCollectionUiLoaderParam(
       
   683         DOCML_NAME_DIALOG,
       
   684         DOCML_VIDEOSELECTIONDIALOG_FILE,
       
   685         true,
       
   686         VideoCollectionUiLoaderParam::LoadPhaseSecondary));
       
   687     params.append(VideoCollectionUiLoaderParam(
       
   688         DOCML_NAME_DLG_HEADINGLBL,
       
   689         DOCML_VIDEOSELECTIONDIALOG_FILE,
       
   690         true,
       
   691         VideoCollectionUiLoaderParam::LoadPhaseSecondary));
       
   692     params.append(VideoCollectionUiLoaderParam(
       
   693         DOCML_NAME_CHECK_CONTAINER,
       
   694         DOCML_VIDEOSELECTIONDIALOG_FILE,
       
   695         true,
       
   696         VideoCollectionUiLoaderParam::LoadPhaseSecondary));
       
   697     params.append(VideoCollectionUiLoaderParam(
       
   698         DOCML_NAME_MARKALL,
       
   699         DOCML_VIDEOSELECTIONDIALOG_FILE,
       
   700         true,
       
   701         VideoCollectionUiLoaderParam::LoadPhaseSecondary));
       
   702     params.append(VideoCollectionUiLoaderParam(
       
   703         DOCML_NAME_LBL_SELECTION,
       
   704         DOCML_VIDEOSELECTIONDIALOG_FILE,
       
   705         true,
       
   706         VideoCollectionUiLoaderParam::LoadPhaseSecondary));
       
   707     params.append(VideoCollectionUiLoaderParam(
       
   708         DOCML_NAME_LIST_CONTAINER,
       
   709         DOCML_VIDEOSELECTIONDIALOG_FILE,
       
   710         true,
       
   711         VideoCollectionUiLoaderParam::LoadPhaseSecondary));
       
   712     mTestObject->addData(params,
       
   713         this,
       
   714         SLOT(handleObjectReady(QObject*, const QString&)));
       
   715     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   716     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhaseSecondary);
       
   717     QTest::qWait(5000); // 5 seconds
       
   718     QCOMPARE(mObjects.count(), params.count());
       
   719     QHash<QString, QObject*>::const_iterator i = mObjects.constBegin();
       
   720     while (i != mObjects.constEnd())
       
   721     {
       
   722         bool found = false;
       
   723         foreach (const VideoCollectionUiLoaderParam &param, params)
       
   724         {
       
   725             if (param == i.key())
       
   726             {
       
   727                 found = true;
       
   728                 break;
       
   729             }
       
   730         }
       
   731         QVERIFY(found);
       
   732         i++;
       
   733     }
       
   734     
       
   735     // Getting proxymodel fails.
       
   736     cleanup();
       
   737     init();
       
   738     mTestObject->addData(params,
       
   739         this,
       
   740         SLOT(handleObjectReady(QObject*, const QString&)));
       
   741     VideoCollectionWrapperData::mGetModelFails = true;
       
   742     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   743     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhaseSecondary);
       
   744     QTest::qWait(5000); // 5 seconds
       
   745     QCOMPARE(mObjects.count(), params.count());
       
   746     i = mObjects.constBegin();
       
   747     while (i != mObjects.constEnd())
       
   748     {
       
   749         bool found = false;
       
   750         foreach (const VideoCollectionUiLoaderParam &param, params)
       
   751         {
       
   752             if (param == i.key())
       
   753             {
       
   754                 found = true;
       
   755                 break;
       
   756             }
       
   757         }
       
   758         QVERIFY(found);
       
   759         i++;
       
   760     }
       
   761     params.clear();
       
   762 }
       
   763 
       
   764 // ---------------------------------------------------------------------------
       
   765 // testDelete
       
   766 // ---------------------------------------------------------------------------
       
   767 //
       
   768 void TestVideoCollectionUiLoader::testDelete()
       
   769 {
       
   770     VideoCollectionWrapperData::reset();
       
   771     
       
   772     // delete:
       
   773     // -load docml
       
   774     // -delete one "root" item
       
   775     bool ok = false;
       
   776     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   777     QVERIFY(ok);
       
   778     HbAction *addToCollection = mTestObject->findObject<HbAction>(DOCML_NAME_ADD_TO_COLLECTION);
       
   779     HbAction *tempAction = addToCollection;
       
   780     delete addToCollection;
       
   781     QVERIFY(!mTestObject->mOrphans.contains(tempAction));
       
   782     cleanup();
       
   783     init();
       
   784 
       
   785     // delete:
       
   786     // -load docml
       
   787     // -delete all items
       
   788     ok = false;
       
   789     mTestObject->load(DOCML_VIDEOCOLLECTIONVIEW_FILE, &ok);
       
   790     foreach (QObject *object, mTestObject->mOrphans)
       
   791     {
       
   792         delete object;
       
   793     }
       
   794     QVERIFY(!mTestObject->mOrphans.count());
       
   795     QVERIFY(ok);
       
   796 }
       
   797 
       
   798 // ---------------------------------------------------------------------------
       
   799 // testRemoveOrphanFromList
       
   800 // ---------------------------------------------------------------------------
       
   801 //
       
   802 void TestVideoCollectionUiLoader::testRemoveOrphanFromList()
       
   803 {
       
   804     QObject *obj = 0;
       
   805     
       
   806     // Nothing in the object lists.
       
   807     cleanup();
       
   808     init();
       
   809     connect(this, SIGNAL(testSignal(QObject *)), mTestObject, SLOT(removeOrphanFromList(QObject *)));
       
   810     emit testSignal(obj);
       
   811     disconnect(this, SIGNAL(testSignal(QObject *)), mTestObject, SLOT(removeOrphanFromList(QObject *)));
       
   812     QCOMPARE(mTestObject->mOrphans.count(), 0);
       
   813     QCOMPARE(mTestObject->mObjects.count(), 0);
       
   814     
       
   815     // Orphans and objects contain the object.
       
   816     cleanup();
       
   817     init();
       
   818     connect(this, SIGNAL(testSignal(QObject *)), mTestObject, SLOT(removeOrphanFromList(QObject *)));
       
   819     obj = new QObject();
       
   820     mTestObject->mOrphans.append(obj);
       
   821     mTestObject->mObjects.insert("test", obj); 
       
   822     emit testSignal(obj);
       
   823     disconnect(this, SIGNAL(testSignal(QObject *)), mTestObject, SLOT(removeOrphanFromList(QObject *)));
       
   824     QCOMPARE(mTestObject->mOrphans.count(), 0);
       
   825     QCOMPARE(mTestObject->mObjects.count(), 0);
       
   826     delete obj;
       
   827 
       
   828     // Orphans contain the object, objects has different
       
   829     cleanup();
       
   830     init();
       
   831     connect(this, SIGNAL(testSignal(QObject *)), mTestObject, SLOT(removeOrphanFromList(QObject *)));
       
   832     obj = new QObject();
       
   833     mTestObject->mOrphans.append(obj);
       
   834     mTestObject->mObjects.insert("test", new QObject()); 
       
   835     emit testSignal(obj);
       
   836     disconnect(this, SIGNAL(testSignal(QObject *)), mTestObject, SLOT(removeOrphanFromList(QObject *)));
       
   837     QCOMPARE(mTestObject->mOrphans.count(), 0);
       
   838     QCOMPARE(mTestObject->mObjects.count(), 1);
       
   839     delete obj;
       
   840 }
       
   841 
       
   842 // TEST CASES END -------------------------------------------------------------
       
   843 
       
   844 void TestVideoCollectionUiLoader::handleObjectReady(QObject *object, const QString &name)
       
   845 {
       
   846     qDebug() << "Received object :" << name;
       
   847     
       
   848     if (object)
       
   849     {
       
   850         if (name == DOCML_NAME_VIEW)
       
   851         {
       
   852             HbMainWindow *window = hbInstance->allMainWindows().at(0);
       
   853             if (window)
       
   854             {
       
   855                 HbView *view = qobject_cast<HbView*>(object);
       
   856                 if (view)
       
   857                 {
       
   858                     window->setCurrentView(view);
       
   859                 }
       
   860             }
       
   861         }
       
   862         mObjects.insert(name, object);
       
   863     }
       
   864 }
       
   865 
       
   866 // ---------------------------------------------------------------------------
       
   867 // testPrepareDocmlAndSection
       
   868 // ---------------------------------------------------------------------------
       
   869 //
       
   870 void TestVideoCollectionUiLoader::testPrepareDocmlAndSection()
       
   871 {
       
   872     VideoCollectionUiLoaderParam banner(
       
   873         DOCML_NAME_VC_HEADINGBANNER,
       
   874         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   875         DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST,
       
   876         true,
       
   877         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   878     VideoCollectionUiLoaderParam collectionWidget(
       
   879         DOCML_NAME_VC_COLLECTIONWIDGET,
       
   880         DOCML_VIDEOCOLLECTIONVIEW_FILE,
       
   881         0,
       
   882         true,
       
   883         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   884     VideoCollectionUiLoaderParam collectionContentWidget(
       
   885         DOCML_NAME_VC_COLLECTIONCONTENTWIDGET,
       
   886         0,
       
   887         DOCML_VIDEOCOLLECTIONVIEW_SECTION_LIST,
       
   888         true,
       
   889         VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   890     const int COUNT = 3;
       
   891     
       
   892     // add items
       
   893     QList<VideoCollectionUiLoaderParam> params;
       
   894     params.append(banner);
       
   895     params.append(collectionWidget);
       
   896     params.append(collectionContentWidget);
       
   897     
       
   898     cleanup();
       
   899     init();
       
   900     HbDocumentLoader::mFindWidgetFails = true;
       
   901     mTestObject->addData(params,
       
   902         this,
       
   903         SLOT(handleObjectReady(QObject*, const QString&)));
       
   904     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   905     QTest::qWait(1000); // wait 1 second
       
   906     QVERIFY(mTestObject->mQueue.count() == 0);
       
   907     QVERIFY(!mTestObject->mQueue.contains(banner));
       
   908     QVERIFY(!mTestObject->mQueue.contains(collectionWidget));
       
   909     QVERIFY(!mTestObject->mQueue.contains(collectionContentWidget));
       
   910     QCOMPARE(mTestObject->mQueue.count(), 0);    
       
   911 
       
   912     cleanup();
       
   913     init();
       
   914     HbDocumentLoader::mFindWidgetFails = true;
       
   915     HbDocumentLoader::mLoadFails = true;
       
   916     mTestObject->addData(params,
       
   917         this,
       
   918         SLOT(handleObjectReady(QObject*, const QString&)));
       
   919     mTestObject->loadPhase(VideoCollectionUiLoaderParam::LoadPhasePrimary);
       
   920     QTest::qWait(1000); // wait 1 second
       
   921     QVERIFY(mTestObject->mQueue.count() == 0);
       
   922     QVERIFY(!mTestObject->mQueue.contains(banner));
       
   923     QVERIFY(!mTestObject->mQueue.contains(collectionWidget));
       
   924     QVERIFY(!mTestObject->mQueue.contains(collectionContentWidget));
       
   925     QCOMPARE(mTestObject->mQueue.count(), 0);    
       
   926 }
       
   927 
       
   928 // end of file