1 /*

     2 * Copyright (c) 2009 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: 

    15 *

    16 */

    17 #include "hbmainwindow.h"

    18 #include "hbapplication.h"

    19 

    20 #include "unittest_medialistwrapper.h"

    21 #include "glxmlwrapper.h"

    22 #include <glxcollectionpluginall.hrh>

    23 #include <glxmodelparm.h>

    24 #include <hbicon.h>

    25 #include <qdatetime.h>

    26 #include <QString>

    27 

    28 

    29 

    30 //#include "glxmlwrapper_p.h"

    31 

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

    33 {

    34     Q_UNUSED(argc);

    35     HbApplication app(argc, argv);	    

    36 

    37     HbMainWindow *mMainWindow = new HbMainWindow();

    38     TestGlxMLWrapper tv;

    39 

    40     char *pass[3];

    41     pass[0] = argv[0];

    42     pass[1] = "-o";

    43     pass[2] = "c:\\data\\testmlwrapper.txt";

    44 

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

    46 

    47     return res;

    48 }

    49 

    50 // -----------------------------------------------------------------------------

    51 // initTestCase

    52 // -----------------------------------------------------------------------------

    53 //

    54 void TestGlxMLWrapper::initTestCase()

    55 {

    56     mTestObject = 0;

    57 }

    58 

    59 // -----------------------------------------------------------------------------

    60 // init

    61 // -----------------------------------------------------------------------------

    62 //

    63 void TestGlxMLWrapper::init()

    64 {

    65    mTestObject = new GlxMLWrapper(KGlxCollectionPluginAllImplementationUid,0,EGlxFilterImage);

    66    QVERIFY(mTestObject);

    67 }

    68 

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

    70 // cleanup

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

    72 //

    73 void TestGlxMLWrapper::cleanup()

    74 {

    75     if(mTestObject)

    76     {

    77         delete mTestObject;

    78         mTestObject = 0;

    79     }  

    80 }

    81 

    82 // -----------------------------------------------------------------------------

    83 // cleanupTestCase

    84 // -----------------------------------------------------------------------------

    85 //

    86 void TestGlxMLWrapper::cleanupTestCase()

    87 {

    88 

    89 }

    90 

    91 // -----------------------------------------------------------------------------

    92 // testGetItemCount

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

    94 //

    95 void TestGlxMLWrapper::testGetItemCount()

    96 {

    97     int count = mTestObject->getItemCount();

    98     QVERIFY(count != 0);

    99 }

   100 

   101 

   102 void TestGlxMLWrapper::testGetFocusIndex()

   103 {

   104     int focusIndex = mTestObject->getFocusIndex();

   105     QVERIFY(focusIndex == -1);

   106     mTestObject->setFocusIndex(mTestObject->getItemCount()-1);

   107     focusIndex = mTestObject->getFocusIndex();

   108     QVERIFY(focusIndex == mTestObject->getItemCount()-1);

   109 }

   110 void TestGlxMLWrapper::testSetFocusIndex()

   111 {

   112     mTestObject->setFocusIndex(mTestObject->getItemCount()-1);

   113     int focusIndex = mTestObject->getFocusIndex();

   114     QVERIFY(focusIndex == mTestObject->getItemCount()-1);

   115 }

   116 void TestGlxMLWrapper::testSetContextMode()

   117 {

   118     int itemIndex = mTestObject->getItemCount()-1;

   119     

   120     //Retriveing without adding any context .so grid icon should be NULL

   121     HbIcon* icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextGrid);

   122     QVERIFY(icon == NULL);

   123     

   124     // After adding grid context should get grid icon 

   125     mTestObject->setContextMode(GlxContextGrid);

   126     QTest::qWait(2000);

   127     icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextGrid);

   128     QVERIFY(icon != NULL);

   129 }

   130 

   131 void TestGlxMLWrapper::testRetrieveItemUri()

   132 {

   133     qDebug("TestGlxMLWrapper::testRetrieveItemUri enter");

   134 	

   135 	int count = mTestObject->getItemCount();

   136 	mTestObject->setContextMode(GlxContextGrid);

   137     QTest::qWait(20000);

   138 	QString uri = mTestObject->retrieveItemUri(count-1);

   139 	qDebug("TestGlxMLWrapper::testRetrieveItemUri =%d",uri.isEmpty());

   140 	QVERIFY( uri.isEmpty() == 0 );

   141 }

   142 

   143 void TestGlxMLWrapper::testRetrieveItemUriName()

   144 {

   145     qDebug("TestGlxMLWrapper::testRetrieveItemUriName enter");

   146 	

   147 	int count = mTestObject->getItemCount();

   148 	mTestObject->setContextMode(GlxContextGrid);

   149     QTest::qWait(20000);

   150     	

   151     QString uri = mTestObject->retrieveItemUri(count-1);

   152 	QString imageName = uri.section('\\',-1);

   153     qDebug("TestGlxMLWrapper::testRetrieveItemUriName =%d",uri.isEmpty());

   154     QVERIFY( imageName.isEmpty() == 0 );

   155 }

   156 

   157 void TestGlxMLWrapper::testRetrieveItemIcon()

   158 {

   159     int itemIndex = mTestObject->getItemCount()-1;

   160     

   161     // grid icon should be NULL

   162     HbIcon* icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextGrid);

   163     QVERIFY(icon == NULL);

   164     

   165     // fullscreen icon should be NULL

   166     icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextLsFs);

   167     QVERIFY(icon == NULL);

   168     

   169     // Should get fullscreen icon 

   170     mTestObject->setContextMode(GlxContextLsFs);

   171     QTest::qWait(4000);

   172     icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextLsFs);

   173     QVERIFY(icon != NULL);

   174     

   175     // Should get grid icon

   176     mTestObject->setContextMode(GlxContextGrid);

   177     QTest::qWait(2000);

   178     icon = mTestObject->retrieveItemIcon(itemIndex,GlxTBContextGrid);

   179     QVERIFY(icon != NULL);

   180 	   

   181 }

   182 

   183 void TestGlxMLWrapper::testRetrieveItemDateIsNotNull()

   184 {

   185     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsNotNull enter");

   186     int count = mTestObject->getItemCount();

   187     mTestObject->setContextMode(GlxContextGrid);

   188     QTest::qWait(20000);

   189 	

   190 	QDate date = mTestObject->retrieveItemDate(count-1);

   191     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsNotNull =%d",date.isNull());

   192     QVERIFY( date.isNull() == 0 );

   193 }

   194 

   195 

   196 void TestGlxMLWrapper::testRetrieveItemDateIsValid()

   197 {

   198     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsValid enter");

   199     int count = mTestObject->getItemCount();

   200     mTestObject->setContextMode(GlxContextGrid);

   201     QTest::qWait(20000);

   202 	

   203 	QDate date = mTestObject->retrieveItemDate(count-1);

   204 	qDebug("TestGlxMLWrapper::testRetrieveItemDateIsValid IsNull=%d",date.isNull());

   205     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsValid IsValid=%d",date.isValid() );

   206 	

   207     QVERIFY( date.isNull() == 0 );

   208     QVERIFY( date.isValid() == 1 );

   209 }

   210 

   211 void TestGlxMLWrapper::testRetrieveItemDateValidate()

   212 {

   213     qDebug("TestGlxMLWrapper::testRetrieveItemDateValidate enter");

   214     int count = mTestObject->getItemCount();

   215 	mTestObject->setContextMode(GlxContextGrid);

   216     QTest::qWait(20000);

   217 	

   218     QDate date = mTestObject->retrieveItemDate(count-1);

   219     qDebug("TestGlxMLWrapper::testRetrieveItemDateValidate =%d",date.isValid(date.year(), date.month(), date.day()) );

   220     QVERIFY( date.isValid(date.year(), date.month(), date.day()) == 1 );

   221 }

   222 

   223 void TestGlxMLWrapper::testGetVisibleWindowIndex()

   224 {

   225     int visibleIndex = mTestObject->getVisibleWindowIndex();

   226     QVERIFY(visibleIndex == 0);

   227     

   228     int itemIndex = mTestObject->getItemCount()-1;

   229     mTestObject->setVisibleWindowIndex(itemIndex);

   230     visibleIndex = mTestObject->getVisibleWindowIndex();

   231     QVERIFY(visibleIndex == itemIndex);

   232 }

   233 

   234 void TestGlxMLWrapper::testSetVisibleWindowIndex()

   235 {

   236     int itemIndex = mTestObject->getItemCount()-1;

   237     mTestObject->setVisibleWindowIndex(itemIndex);

   238     int visibleIndex = mTestObject->getVisibleWindowIndex();

   239     QVERIFY(visibleIndex == itemIndex);

   240 }

   241 

   242 void TestGlxMLWrapper::testItemsAdded()

   243 {

   244     QSignalSpy spysignal(mTestObject, SIGNAL(insertItems(int ,int )));

   245     QVERIFY(spysignal.count() == 0);

   246     

   247     int index = mTestObject->getItemCount();

   248     spysignal.clear(); 

   249 

   250     mTestObject->itemsAdded(index,index + 5);

   251     qDebug("Signal Count %d",spysignal.count());

   252     QVERIFY(spysignal.count() == 1);

   253     QVERIFY(spysignal.value(0).at(0).toInt() == index);

   254     QVERIFY(spysignal.value(0).at(1).toInt() == index+5);

   255 

   256     mTestObject->itemsAdded(index + 6,index + 6);

   257     qDebug("Signal #Count %d",spysignal.count());

   258     QVERIFY(spysignal.count() == 2);

   259     QVERIFY(spysignal.value(1).at(0).toInt() == index+6);

   260     QVERIFY(spysignal.value(1).at(1).toInt() == index+6);

   261 }

   262 

   263 void TestGlxMLWrapper::testItemsRemoved()

   264 {

   265     QSignalSpy spysignal(mTestObject, SIGNAL(removeItems(int ,int )));

   266     QVERIFY(spysignal.count() == 0);

   267     

   268     int index = mTestObject->getItemCount();

   269     spysignal.clear(); 

   270 

   271     mTestObject->itemsRemoved(index,index + 5);

   272     qDebug("Signal Count %d",spysignal.count());

   273     QVERIFY(spysignal.count() == 1);

   274     QVERIFY(spysignal.value(0).at(0).toInt() == index);

   275     QVERIFY(spysignal.value(0).at(1).toInt() == index+5);

   276 

   277     mTestObject->itemsRemoved(index + 6,index + 6);

   278     qDebug("Signal #Count %d",spysignal.count());

   279     QVERIFY(spysignal.count() == 2);

   280     QVERIFY(spysignal.value(1).at(0).toInt() == index+6);

   281     QVERIFY(spysignal.value(1).at(1).toInt() == index+6);

   282 }

   283 

   284 void TestGlxMLWrapper::testHandleReceivedIcon()

   285 {

   286     qRegisterMetaType<GlxTBContextType>("GlxTBContextType");

   287     QSignalSpy spysignal(mTestObject, SIGNAL(updateItem(int , GlxTBContextType )));

   288     QVERIFY(spysignal.count() == 0);

   289     

   290     int count = mTestObject->getItemCount();

   291     spysignal.clear(); 

   292 

   293     mTestObject->handleReceivedIcon(count-1,GlxTBContextGrid);

   294     qDebug("Signal Count %d",spysignal.count());

   295     QVERIFY(spysignal.count() == 1);

   296     QVERIFY(spysignal.value(0).at(0).toInt() == count-1);

   297     QVERIFY(spysignal.value(0).at(1).toInt() == GlxTBContextGrid);

   298     spysignal.clear(); 

   299 

   300     // mTestObject->handleReceivedIcon(count-1,GlxTBContextLsFs);

   301     // qDebug("Signal Count %d",spysignal.count());

   302     // QVERIFY(spysignal.count() == 1);

   303     // QVERIFY(spysignal.value(0).at(0).toInt() == count-1);

   304     // QVERIFY(spysignal.value(0).at(1).toInt() == GlxTBContextLsFs);

   305     // spysignal.clear(); 

   306 

   307     // mTestObject->handleReceivedIcon(count-1,GlxTBContextPtFs);

   308     // qDebug("Signal Count %d",spysignal.count());

   309     // QVERIFY(spysignal.count() == 1);

   310     // QVERIFY(spysignal.value(0).at(0).toInt() == count-1);

   311     // QVERIFY(const_cast<GlxTBContextType>(spysignal.value(0).at(1)) == GlxTBContextPtFs);

   312 

   313 }

   314 

   315 void TestGlxMLWrapper::testHandleIconCorrupt()

   316 {

   317     QSignalSpy spysignal(mTestObject, SIGNAL(itemCorrupted(int )));

   318     QVERIFY(spysignal.count() == 0);

   319     

   320     int index = mTestObject->getItemCount();

   321     spysignal.clear(); 

   322 

   323     mTestObject->handleIconCorrupt(index-1);

   324     qDebug("Signal Count %d",spysignal.count());

   325     QVERIFY(spysignal.count() == 1);

   326     QVERIFY(spysignal.value(0).at(0).toInt() == index-1);

   327 

   328 }

   329 

   330 void TestGlxMLWrapper::testHandleListItemAvailable()

   331 {

   332     qRegisterMetaType<GlxTBContextType>("GlxTBContextType");

   333     QSignalSpy spysignal(mTestObject, SIGNAL(updateItem(int , GlxTBContextType )));

   334     QVERIFY(spysignal.count() == 0);

   335     

   336     int count = mTestObject->getItemCount();

   337     spysignal.clear(); 

   338 

   339     mTestObject->handleListItemAvailable(count-1);

   340     qDebug("Signal Count %d",spysignal.count());

   341     QVERIFY(spysignal.count() == 1);

   342     QVERIFY(spysignal.value(0).at(0).toInt() == count-1);

   343 	qDebug("update Item enum %d",spysignal.value(0).at(1).toInt());

   344     QVERIFY(spysignal.value(0).at(1).toInt() == 3);

   345 

   346 }

   347 

   348 void TestGlxMLWrapper::testRetrieveItemDateIsNull()

   349 {

   350     int count = mTestObject->getItemCount();

   351     QDate date = mTestObject->retrieveItemDate(count-1);

   352     qDebug("TestGlxMLWrapper::testRetrieveItemDateIsNull =%d",date.isNull());

   353     QVERIFY( date.isNull() == 1 );

   354 }