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 *       test application for qt control panel public apis.

    16 */

    17 

    18 #include "ut_cpitemdatahelper.h"

    19 

    20 #include <cpitemdatahelper.h>

    21 #include <QtTest/QtTest>

    22 #include <hbdataformmodel.h>

    23 #include <hbdataform.h>

    24 #include <hbdataformviewitem.h>

    25 #include <QModelIndex>

    26 

    27 /*!

    28     \class TestCpItemDataHelper

    29     \brief The TestCpItemDataHelper class is designed for the unit testing for CpItemDataHelper class.

    30     This unit test is supported by QTest.

    31     There are total 21 test cases in this unit.

    32  */

    33 

    34 void TestCpItemDataHelper::initTestCase()

    35     {

    36     }

    37 

    38 void TestCpItemDataHelper::cleanupTestCase()

    39     {

    40     QCoreApplication::processEvents();

    41     }

    42 

    43 /*!

    44  * Test Case Description:\n  

    45  * 1. Fucntion Name: CpItemDataHelper() \n 

    46    2. Function Descrition: \n   

    47        2.1 Create CpItemDataHelper object with a 0 pointer.\n   

    48        2.2 verify object created successfully.\n   

    49        2.3 delete the object.\n  

    50    3. Input Parameters: \n 

    51        @param: none.\n

    52    4. Expected result: \n  

    53        case run without verify failed.\n 

    54  */

    55 void TestCpItemDataHelper::testCpItemDataHelperWithNullPointer()

    56     {

    57     CpItemDataHelper *pHelper = new CpItemDataHelper();

    58     QVERIFY(pHelper != 0);

    59     

    60     delete pHelper;

    61     }

    62 

    63 /*!

    64  * Test Case Description:\n  

    65  * 1. Fucntion Name: CpItemDataHelper() \n 

    66    2. Function Descrition: \n   

    67        2.1 Create CpItemDataHelper object with a HbDataForm pointer.\n   

    68        2.2 verify object created successfully.\n   

    69        2.3 delete the object.\n  

    70    3. Input Parameters: valid HbDataForm object pointer. \n 

    71    4. Expected result: \n  

    72        case run without verify failed.\n 

    73  */

    74 void TestCpItemDataHelper::testCpItemDataHelperWithDataForm()

    75     {

    76     HbDataForm* form = new HbDataForm();

    77     QVERIFY(form != 0);

    78     

    79     HbDataFormModel *model = new HbDataFormModel();

    80     QVERIFY(model != 0);

    81     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

    82     QVERIFY(general != 0);

    83     

    84     form->setModel(model);

    85     

    86     CpItemDataHelper *pHelper = new CpItemDataHelper(form);

    87     QVERIFY(pHelper != 0);

    88     

    89     delete pHelper;

    90     delete form;

    91     }

    92 

    93 /*!

    94  * Test Case Description:\n  

    95  * 1. Fucntion Name: bindToForm() \n 

    96    2. Function Descrition: \n   

    97        2.1 Create CpItemDataHelper object with a 0 pointer.\n   

    98        2.2 call bindToForm later.\n   

    99        2.3 delete the object.\n  

   100    3. Input Parameters: 0/HbDataForm object pointer. \n 

   101    4. Expected result: \n  

   102        case run without verify failed.\n 

   103  */

   104 void TestCpItemDataHelper::testBindToFormWithDataForm()

   105     {

   106     HbDataForm* form = new HbDataForm();

   107     QVERIFY(form != 0);

   108     HbDataFormModel *model = new HbDataFormModel();

   109     QVERIFY(model != 0);

   110     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   111     QVERIFY(general != 0);

   112     

   113     form->setModel(model);

   114     

   115     CpItemDataHelper *pHelper = new CpItemDataHelper();

   116     QVERIFY(pHelper != 0);

   117 

   118     //to increase the branch coverage

   119     pHelper->bindToForm(form);

   120     pHelper->bindToForm(form);

   121     pHelper->bindToForm(0);

   122     pHelper->bindToForm(form);

   123     

   124     delete pHelper;

   125     delete form;

   126     }

   127     

   128 /*!

   129  * Test Case Description:\n  

   130  * 1. Fucntion Name: addItemPrototype() \n 

   131    2. Function Descrition: \n   

   132        2.1 Create CpItemDataHelper object with a 0 pointer.\n   

   133        2.2 call addItemPrototype, provide 0 pointer.\n   

   134        2.3 delete the object.\n  

   135    3. Input Parameters: 0. \n 

   136    4. Expected result: \n  

   137        case run without verify failed.\n 

   138  */

   139 void TestCpItemDataHelper::testAddItemPrototypeWithNullPointer1()

   140     {

   141     HbDataForm* form = new HbDataForm();

   142     QVERIFY(form != 0);

   143     HbDataFormModel *model = new HbDataFormModel();

   144     QVERIFY(model != 0);

   145     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   146     QVERIFY(general != 0);

   147     

   148     form->setModel(model);

   149     

   150     CpItemDataHelper *pHelper = new CpItemDataHelper();

   151     QVERIFY(pHelper != 0);

   152     

   153     int count1 = form->itemPrototypes().count();

   154     HbDataFormViewItem * pitem1 = 0;

   155     //pass 0 proto type

   156     pHelper->addItemPrototype(pitem1);

   157     int count2 = form->itemPrototypes().count();

   158     QVERIFY(count1 == count2);

   159     

   160     delete pHelper;

   161     delete form;

   162     }

   163 

   164 /*!

   165  * Test Case Description:\n  

   166  * 1. Fucntion Name: addItemPrototype() \n 

   167    2. Function Descrition: \n   

   168    3. Input Parameters: HbDataFormViewItem object pointer. \n 

   169    4. Expected result: \n  

   170        case run without verify failed.\n 

   171  */

   172 void TestCpItemDataHelper::testAddItemPrototypeWithViewItem1()

   173     {

   174     HbDataForm* form = new HbDataForm();

   175     QVERIFY(form != 0);

   176     HbDataFormModel *model = new HbDataFormModel();

   177     QVERIFY(model != 0);

   178     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   179     QVERIFY(general != 0);

   180     

   181     form->setModel(model);

   182     

   183     CpItemDataHelper *pHelper = new CpItemDataHelper();

   184     QVERIFY(pHelper != 0);

   185     

   186     int count1 = form->itemPrototypes().count();

   187     HbDataFormViewItem * pitem1 = new HbDataFormViewItem();

   188     //pass 0 proto type

   189     pHelper->addItemPrototype(pitem1);

   190     int count2 = form->itemPrototypes().count();

   191     QVERIFY(count1 == count2);

   192     

   193     pHelper->bindToForm(form);

   194     int count3 = form->itemPrototypes().count();

   195     QVERIFY(count1 + 1 == count3);

   196     

   197     delete pHelper;

   198     delete form;

   199     }

   200 

   201 /*!

   202  * Create CpItemDataHelper instance, call addItemPrototype with 0

   203  */

   204 /*!

   205  * Test Case Description:\n  

   206  * 1. Fucntion Name: addItemPrototype() \n 

   207    2. Function Descrition: \n   

   208    3. Input Parameters: 0 pointer. \n 

   209    4. Expected result: \n  

   210        case run without verify failed.\n 

   211  */

   212 void TestCpItemDataHelper::testAddItemPrototypeWithNullPointer2()

   213     {

   214     HbDataForm* form = new HbDataForm();

   215     QVERIFY(form != 0);

   216     HbDataFormModel *model = new HbDataFormModel();

   217     QVERIFY(model != 0);

   218     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   219     QVERIFY(general != 0);

   220     

   221     form->setModel(model);

   222     

   223     CpItemDataHelper *pHelper = new CpItemDataHelper(form);

   224     QVERIFY(pHelper != 0);

   225     

   226     int count1 = form->itemPrototypes().count();

   227     HbDataFormViewItem * pitem1 = 0;

   228     //pass 0 proto type

   229     pHelper->addItemPrototype(pitem1);

   230     int count2 = form->itemPrototypes().count();

   231     QVERIFY(count1 == count2);

   232     

   233     delete pHelper;

   234     delete form;

   235     }

   236 

   237 /*!

   238  * Test Case Description:\n  

   239  * 1. Fucntion Name: addItemPrototype() \n 

   240    2. Function Descrition: \n   

   241    3. Input Parameters: HbDataFormViewItem object pointer. \n 

   242    4. Expected result: \n  

   243        case run without verify failed.\n 

   244  */

   245 void TestCpItemDataHelper::testAddItemPrototypeWithViewItem2()

   246     {

   247     HbDataForm* form = new HbDataForm();

   248     QVERIFY(form != 0);

   249     HbDataFormModel *model = new HbDataFormModel();

   250     QVERIFY(model != 0);

   251     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   252     QVERIFY(general != 0);

   253     

   254     form->setModel(model);

   255     

   256     CpItemDataHelper *pHelper = new CpItemDataHelper();

   257     QVERIFY(pHelper != 0);

   258     

   259     pHelper->bindToForm(form);

   260     

   261     int count1 = form->itemPrototypes().count();

   262     HbDataFormViewItem * pitem1 = new HbDataFormViewItem();

   263     //pass 0 proto type

   264     pHelper->addItemPrototype(pitem1);

   265     int count2 = form->itemPrototypes().count();

   266     QVERIFY(count1 + 1 == count2);

   267     

   268     delete pHelper;

   269     delete form;

   270     }

   271     

   272 /*!

   273  * Test Case Description:\n  

   274  * 1. Fucntion Name: addConnection(HbDataFormModelItem *item,

   275         const char *signal,

   276         QObject *receiver,

   277         const char *method) \n 

   278    2. Function Descrition: \n   

   279    3. Input Parameters: \n 

   280    4. Expected result: \n  

   281        case run without verify failed.\n 

   282  */

   283 void TestCpItemDataHelper::testAddConnectionWithnoDataForm()

   284     {

   285     HbDataForm* form = new HbDataForm();

   286     QVERIFY(form != 0);

   287     HbDataFormModel *model = new HbDataFormModel();

   288     QVERIFY(model != 0);

   289     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   290     QVERIFY(general != 0);

   291     

   292     form->setModel(model);

   293     

   294     CpItemDataHelper *pHelper = new CpItemDataHelper();

   295     QVERIFY(pHelper != 0);

   296     

   297     pHelper->addConnection( general, "hello", form, "hello");

   298     

   299     delete pHelper;

   300     delete form;

   301     }

   302 

   303 /*!

   304  * Test Case Description:\n  

   305  * 1. Fucntion Name: addConnection(HbDataFormModelItem *item,

   306         const char *signal,

   307         QObject *receiver,

   308         const char *method) \n 

   309    2. Function Descrition: \n   

   310    3. Input Parameters: \n 

   311    4. Expected result: \n  

   312        case run without verify failed.\n 

   313  */

   314 void TestCpItemDataHelper::testAddConnectionWithDataForm()

   315     {

   316     HbDataForm* form = new HbDataForm();

   317     QVERIFY(form != 0);

   318     HbDataFormModel *model = new HbDataFormModel();

   319     QVERIFY(model != 0);

   320     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   321     QVERIFY(general != 0);

   322     

   323     form->setModel(model);

   324     

   325     CpItemDataHelper *pHelper = new CpItemDataHelper(form);

   326     QVERIFY(pHelper != 0);

   327     

   328     pHelper->addConnection( general, "hello", form, "hello");

   329     

   330     delete pHelper;

   331     delete form;

   332     }

   333 

   334 /*!

   335  * Test Case Description:\n  

   336  * 1. Fucntion Name: removeConnection(HbDataFormModelItem *item,

   337         const char *signal,

   338         QObject *receiver,

   339         const char *method) \n 

   340    2. Function Descrition: \n   

   341    3. Input Parameters: \n 

   342    4. Expected result: \n  

   343        case run without verify failed.\n 

   344  */

   345 void TestCpItemDataHelper::testRemoveConnectionNoDataForm()

   346     {

   347     HbDataForm* form = new HbDataForm();

   348     QVERIFY(form != 0);

   349     HbDataFormModel *model = new HbDataFormModel();

   350     QVERIFY(model != 0);

   351     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   352     QVERIFY(general != 0);

   353     

   354     form->setModel(model);

   355     

   356     CpItemDataHelper *pHelper = new CpItemDataHelper();

   357     QVERIFY(pHelper != 0);

   358     

   359     pHelper->addConnection( general, "hello", form, "hello");

   360     pHelper->removeConnection(general,"hello", form, "hello");

   361     

   362     delete pHelper;

   363     delete form;

   364     }

   365 

   366 /*!

   367  * Test Case Description:\n  

   368  * 1. Fucntion Name: removeConnection(HbDataFormModelItem *item,

   369         const char *signal,

   370         QObject *receiver,

   371         const char *method) \n 

   372    2. Function Descrition: \n   

   373    3. Input Parameters: \n 

   374    4. Expected result: \n  

   375        case run without verify failed.\n 

   376  */

   377 void TestCpItemDataHelper::testRemoveConnectionWithDataForm()

   378     {

   379     HbDataForm* form = new HbDataForm();

   380     QVERIFY(form != 0);

   381     HbDataFormModel *model = new HbDataFormModel();

   382     QVERIFY(model != 0);

   383     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   384     QVERIFY(general != 0);

   385     

   386     form->setModel(model);

   387     

   388     CpItemDataHelper *pHelper = new CpItemDataHelper(form);

   389     QVERIFY(pHelper != 0);

   390     

   391     pHelper->addConnection( general, "hello", form, "hello");

   392     pHelper->removeConnection(general,"hello", form, "hello");

   393     

   394     delete pHelper;

   395     delete form;

   396     }

   397 

   398 /*!

   399  * Test Case Description:\n  

   400  * 1. Fucntion Name: connectToForm(const char *signal,

   401         QObject *receiver,

   402         const char *method) \n 

   403    2. Function Descrition: \n   

   404    3. Input Parameters: \n 

   405    4. Expected result: \n  

   406        case run without verify failed.\n 

   407  */

   408 void TestCpItemDataHelper::testConnectToFormNoDataForm()

   409     {

   410     HbDataForm* form = new HbDataForm();

   411     QVERIFY(form != 0);

   412     HbDataFormModel *model = new HbDataFormModel();

   413     QVERIFY(model != 0);

   414     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   415     QVERIFY(general != 0);

   416     

   417     form->setModel(model);

   418     

   419     CpItemDataHelper *pHelper = new CpItemDataHelper();

   420     QVERIFY(pHelper != 0);

   421     

   422     pHelper->connectToForm("hello", form, "hello");

   423     

   424     delete pHelper;

   425     delete form;

   426     }

   427 

   428 /*!

   429  * Test Case Description:\n  

   430  * 1. Fucntion Name: connectToForm(const char *signal,

   431         QObject *receiver,

   432         const char *method) \n 

   433    2. Function Descrition: \n   

   434    3. Input Parameters: \n 

   435    4. Expected result: \n  

   436        case run without verify failed.\n 

   437  */

   438 void TestCpItemDataHelper::testConnectToFormWithDataForm()

   439     {

   440     HbDataForm* form = new HbDataForm();

   441     QVERIFY(form != 0);

   442     HbDataFormModel *model = new HbDataFormModel();

   443     QVERIFY(model != 0);

   444     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   445     QVERIFY(general != 0);

   446     

   447     form->setModel(model);

   448     

   449     CpItemDataHelper *pHelper = new CpItemDataHelper(form);

   450     QVERIFY(pHelper != 0);

   451     

   452     pHelper->connectToForm("hello", form, "hello");

   453     

   454     delete pHelper;

   455     delete form;

   456     }

   457 

   458 /*!

   459  * Test Case Description:\n  

   460  * 1. Fucntion Name: disconnectFromForm(const char *signal,

   461         QObject *receiver,

   462         const char *method) \n 

   463    2. Function Descrition: \n   

   464    3. Input Parameters: \n 

   465    4. Expected result: \n  

   466        case run without verify failed.\n 

   467  */

   468 void TestCpItemDataHelper::testDisconnectToFormNoDataForm()

   469     {

   470     HbDataForm* form = new HbDataForm();

   471     QVERIFY(form != 0);

   472     HbDataFormModel *model = new HbDataFormModel();

   473     QVERIFY(model != 0);

   474     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   475     QVERIFY(general != 0);

   476     

   477     form->setModel(model);

   478     

   479     CpItemDataHelper *pHelper = new CpItemDataHelper();

   480     QVERIFY(pHelper != 0);

   481     

   482     pHelper->connectToForm("hello", form, "hello");

   483     pHelper->disconnectFromForm("hello", form, "hello");

   484     

   485     delete pHelper;

   486     delete form;

   487     }

   488 

   489 /*!

   490  * Test Case Description:\n  

   491  * 1. Fucntion Name: disconnectFromForm(const char *signal,

   492         QObject *receiver,

   493         const char *method) \n 

   494    2. Function Descrition: \n   

   495    3. Input Parameters: \n 

   496    4. Expected result: \n  

   497        case run without verify failed.\n 

   498  */

   499 void TestCpItemDataHelper::testDisconnectToFormWithDataForm()

   500     {

   501     HbDataForm* form = new HbDataForm();

   502     QVERIFY(form != 0);

   503     HbDataFormModel *model = new HbDataFormModel();

   504     QVERIFY(model != 0);

   505     HbDataFormModelItem *general = model->appendDataFormPage(QString("General"));

   506     QVERIFY(general != 0);

   507     

   508     form->setModel(model);

   509     

   510     CpItemDataHelper *pHelper = new CpItemDataHelper(form);

   511     QVERIFY(pHelper != 0);

   512     

   513     pHelper->connectToForm("hello", form, "hello");

   514     pHelper->disconnectFromForm("hello", form, "hello");

   515     

   516     delete pHelper;

   517     delete form;

   518     delete model;

   519     }

   520 

   521 /*!

   522  * Test Case Description:\n  

   523  * 1. Fucntion Name: HbWidget *widgetFromModelIndex(const QModelIndex &index); \n 

   524    2. Function Descrition: \n   

   525    3. Input Parameters: QModelIndex object. \n 

   526    4. Expected result: \n  

   527        case run without verify failed.\n 

   528  */

   529 void TestCpItemDataHelper::testWidgetFromModelIndexWithDataForm()

   530     {

   531     HbDataForm* form = new HbDataForm();

   532     QVERIFY( form != 0 );

   533     

   534     HbDataFormModel *model = new HbDataFormModel();

   535     QVERIFY( model != 0 );

   536     

   537     HbDataFormModelItem *general = model->appendDataFormItem(HbDataFormModelItem::TextItem, QString("General"));

   538     QVERIFY( general != 0 );

   539     

   540     HbDataFormModelItem *special = model->appendDataFormItem(HbDataFormModelItem::SliderItem, QString("Special"));

   541     QVERIFY( special != 0 );

   542     

   543     CpItemDataHelper *phelper = new CpItemDataHelper(form);

   544     QVERIFY( phelper != 0 );

   545     

   546     form->setModel(model);

   547     

   548     QModelIndex index = model->indexFromItem(special);

   549     

   550     HbWidget * widget = phelper->widgetFromModelIndex(index);

   551     QVERIFY( widget != 0 );

   552     QVERIFY( widget->type() == Hb::ItemType_Slider );

   553     

   554     delete phelper;

   555     delete form;

   556     delete model;

   557     }

   558 

   559 /*!

   560  * Test Case Description:\n  

   561  * 1. Fucntion Name: HbWidget *widgetFromModelIndex(const QModelIndex &index); \n 

   562    2. Function Descrition: \n   

   563    3. Input Parameters: QModelIndex object. \n 

   564    4. Expected result: \n  

   565        case run without verify failed.\n 

   566  */

   567 void TestCpItemDataHelper::testWidgetFromModelIndexNoDataForm()

   568     {

   569     HbDataForm* form = new HbDataForm();

   570     QVERIFY( form != 0 );

   571     

   572     HbDataFormModel *model = new HbDataFormModel();

   573     QVERIFY( model != 0 );

   574     

   575     HbDataFormModelItem *general = model->appendDataFormItem(HbDataFormModelItem::SliderItem, QString("General"));

   576     QVERIFY( general != 0 );

   577     

   578     form->setModel(model);

   579     

   580     CpItemDataHelper *phelper = new CpItemDataHelper();

   581     QVERIFY( phelper != 0 );

   582     

   583     QModelIndex index = model->indexFromItem(general);

   584     HbWidget * widget = phelper->widgetFromModelIndex(index);

   585     QVERIFY( widget == 0 );

   586     

   587     phelper->bindToForm(form);

   588     HbWidget * widget1 = phelper->widgetFromModelIndex(index);

   589     QVERIFY( widget1 != 0 );

   590     QVERIFY( widget1->type() == Hb::ItemType_Slider );

   591     

   592     delete phelper;

   593     delete form;

   594     delete model;

   595     }

   596 

   597 /*!

   598  * Test Case Description:\n  

   599  * 1. Fucntion Name: HbWidget *widgetFromModelIndex(const QModelIndex &index); \n 

   600    2. Function Descrition: \n   

   601    3. Input Parameters: QModelIndex object. \n 

   602    4. Expected result: \n  

   603        case run without verify failed.\n 

   604  */

   605 void TestCpItemDataHelper::testWidgetFromModelIndexWithDataFormBinded()

   606     {

   607     HbDataForm* form = new HbDataForm();

   608     QVERIFY( form != 0 );

   609     

   610     HbDataFormModel *model = new HbDataFormModel();

   611     QVERIFY( model != 0 );

   612     

   613     HbDataFormModelItem *general = model->appendDataFormItem(HbDataFormModelItem::SliderItem, QString("General"));

   614     QVERIFY( general != 0 );

   615     

   616     HbDataFormModelItem * general1 = new HbDataFormModelItem();

   617     QVERIFY( general1 != 0 );

   618     

   619     form->setModel(model);

   620     

   621     CpItemDataHelper *phelper = new CpItemDataHelper(form);

   622     QVERIFY( phelper != 0 );

   623     

   624     QModelIndex index = model->indexFromItem(general1);

   625     HbWidget * widget = phelper->widgetFromModelIndex(index);

   626     QVERIFY( widget == 0 );

   627     

   628     phelper->bindToForm(form);

   629     HbWidget * widget1 = phelper->widgetFromModelIndex(index);

   630     QVERIFY( widget1 == 0 );

   631     

   632     delete phelper;

   633     delete form;

   634     delete model;

   635     }

   636 

   637 /*!

   638  * Test Case Description:\n  

   639  * 1. Fucntion Name: HbDataFormModelItem *modelItemFromModelIndex(const QModelIndex &index); \n 

   640    2. Function Descrition: \n   

   641    3. Input Parameters: QModelIndex object. \n 

   642    4. Expected result: \n  

   643        case run without verify failed.\n 

   644  */

   645 void TestCpItemDataHelper::testModelItemFromModelIndexWithDataForm()

   646     {

   647     HbDataForm* form = new HbDataForm();

   648     QVERIFY( form != 0 );

   649     

   650     HbDataFormModel *model = new HbDataFormModel();

   651     QVERIFY( model != 0 );

   652     

   653     HbDataFormModelItem *general = model->appendDataFormItem(HbDataFormModelItem::TextItem, QString("General"));

   654     QVERIFY( general != 0 );

   655     

   656     HbDataFormModelItem *special = model->appendDataFormItem(HbDataFormModelItem::SliderItem, QString("Special"));

   657     QVERIFY( special != 0 );

   658     

   659     CpItemDataHelper *phelper = new CpItemDataHelper(form);

   660     QVERIFY( phelper != 0 );

   661     

   662     form->setModel(model);

   663     

   664     QModelIndex index = model->indexFromItem(special);

   665     

   666     HbDataFormModelItem * item = phelper->modelItemFromModelIndex(index);

   667     QVERIFY( item != 0 );

   668     QVERIFY( item->type() == HbDataFormModelItem::SliderItem );

   669     

   670     delete phelper;

   671     delete form;

   672     delete model;

   673     }

   674 

   675 /*!

   676  * Test Case Description:\n  

   677  * 1. Fucntion Name: HbDataFormModelItem *modelItemFromModelIndex(const QModelIndex &index); \n 

   678    2. Function Descrition: \n   

   679    3. Input Parameters: QModelIndex object. \n 

   680    4. Expected result: \n  

   681        case run without verify failed.\n 

   682  */

   683 void TestCpItemDataHelper::testModelItemFromModelIndexNoDataForm()

   684     {

   685     HbDataForm* form = new HbDataForm();

   686     QVERIFY( form != 0 );

   687     

   688     HbDataFormModel *model = new HbDataFormModel();

   689     QVERIFY( model != 0 );

   690     

   691     HbDataFormModelItem *general = model->appendDataFormItem(HbDataFormModelItem::SliderItem, QString("General"));

   692     QVERIFY( general != 0 );

   693     

   694     form->setModel(model);

   695     

   696     CpItemDataHelper *phelper = new CpItemDataHelper();

   697     QVERIFY( phelper != 0 );

   698     

   699     QModelIndex index = model->indexFromItem(general);

   700     HbDataFormModelItem * item = phelper->modelItemFromModelIndex(index);

   701     QVERIFY( item == 0 );

   702     

   703     phelper->bindToForm(form);

   704     

   705     HbDataFormModelItem * item1 = phelper->modelItemFromModelIndex(index);

   706     QVERIFY( item1 != 0 );

   707     QVERIFY( item1->type() == HbDataFormModelItem::SliderItem );

   708     

   709     delete phelper;

   710     delete form;

   711     delete model;

   712     }

   713 

   714 /*!

   715  * Test Case Description:\n  

   716  * 1. Fucntion Name: HbDataFormModelItem *modelItemFromModelIndex(const QModelIndex &index); \n 

   717    2. Function Descrition: \n   

   718    3. Input Parameters: QModelIndex object. \n 

   719    4. Expected result: \n  

   720        case run without verify failed.\n 

   721  */

   722 void TestCpItemDataHelper::testModelItemFromModelIndexWithModel()

   723     {

   724     HbDataForm* form = new HbDataForm();

   725     QVERIFY( form != 0 );

   726     

   727     HbDataFormModel *model = new HbDataFormModel();

   728     QVERIFY( model != 0 );

   729     

   730     HbDataFormModelItem *general = model->appendDataFormItem(HbDataFormModelItem::SliderItem, QString("General"));

   731     QVERIFY( general != 0 );

   732     

   733     HbDataFormModelItem * general1 = new HbDataFormModelItem();

   734     QVERIFY( general1 != 0 );

   735     

   736     CpItemDataHelper *phelper = new CpItemDataHelper(form);

   737     QVERIFY( phelper != 0 );

   738     

   739     QModelIndex index = model->indexFromItem(general1);

   740     HbDataFormModelItem * item = phelper->modelItemFromModelIndex(index);

   741     QVERIFY( item == 0 );

   742 

   743     form->setModel(model);

   744     

   745     HbDataFormModelItem * item1 = phelper->modelItemFromModelIndex(index);

   746     QVERIFY( item1 == 0 );

   747     

   748     delete phelper;

   749     delete form;

   750     delete model;

   751     }

   752 

   753 QTEST_MAIN(TestCpItemDataHelper)