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 *  Version     : %version: 3 %

    17 */

    18 #include <QtTest/QtTest>

    19 #include <hgwidgets/hgcacheproxymodel.h>

    20 #include "test_hgcacheproxydatamodel.h"

    21 

    22 #include "../../inc/hgbuffermanager.h"

    23 #include "bmhelper.h"

    24 

    25 #include "dataproviderhelper.h"

    26 #include "cacheproxyhelper.h"

    27 #include <QtDebug>

    28 

    29 // ======== MEMBER FUNCTIONS ========

    30 void TestCacheProxy::testQAbstractItemModel(QAbstractItemModel* model, int rows, int columns)

    31 {

    32     QVERIFY(model != 0);

    33     QModelIndex idx = model->index(0, 0);

    34     if ( rows > 0 && columns > 0){

    35         QVERIFY(idx.isValid() == true);

    36         QVERIFY(idx.row() == 0);

    37         QVERIFY(idx.column() == 0);

    38         

    39         idx = model->index(rows/2, 0);

    40         QVERIFY(idx.row() == rows/2);

    41         QVERIFY(idx.column() == 0);

    42         

    43         idx = model->index(0, columns/2);

    44         QVERIFY(idx.row() == 0);

    45         QVERIFY(idx.column() == columns/2);

    46     

    47         idx = model->index(-10, 0);

    48         QVERIFY(idx.row() == -10);

    49         QVERIFY(idx.column() == 0);

    50     

    51         idx = model->index(0, -10);

    52         QVERIFY(idx.row() == 0);

    53         QVERIFY(idx.column() == -10);

    54         

    55         idx = model->index(rows*2, 0);

    56         QVERIFY(idx.row() == -1);

    57         QVERIFY(idx.column() == 0);

    58     

    59         idx = model->index(0, columns*2);

    60         QVERIFY(idx.row() == 0);

    61         QVERIFY(idx.column() == -1);

    62     }else{

    63         QVERIFY(idx.row() == -1);

    64         QVERIFY(idx.column() == -1);

    65         

    66         idx = model->index(-10, 0);

    67         QVERIFY(idx.row() == -10);

    68         QVERIFY(idx.column() == -1);

    69 

    70         idx = model->index(0, -10);

    71         QVERIFY(idx.row() == -1);

    72         QVERIFY(idx.column() == -10);

    73 

    74         idx = model->index(10, 0);

    75         QVERIFY(idx.row() == -1);

    76         QVERIFY(idx.column() == -1);

    77         

    78         idx = model->index(0, 10);

    79         QVERIFY(idx.row() == -1);

    80         QVERIFY(idx.column() == -1);

    81     }

    82     

    83     idx = model->parent(idx);

    84     QVERIFY(idx.isValid() == false);

    85     QVERIFY(model->columnCount() == columns);

    86     QVERIFY(model->rowCount() == rows);

    87     

    88 //    QVERIFY(model->hasChildren() == false);

    89 //    QVERIFY(model->headerData(0, Qt::Horizontal).isValid == false);

    90     

    91 }

    92 

    93 void TestCacheProxy::initTestCase()

    94 {

    95     bm = 0;

    96     bmh = 0;

    97     dph = 0;

    98     cp = 0;   

    99     cph = 0;

   100 }

   101     

   102 void TestCacheProxy::cleanupTestCase()

   103 {

   104     delete bm;

   105     delete bmh;

   106     delete dph;   

   107     delete cp;

   108     delete cph;

   109 }

   110 

   111 void TestCacheProxy::init()

   112 {

   113     delete bm;

   114     delete bmh;

   115     bm = 0;

   116     bmh = 0;

   117 

   118     delete dph;

   119     dph = 0;

   120     

   121     delete cp;

   122     cp = 0;

   123     

   124     delete cph;

   125     cph = 0;

   126 }

   127 

   128 void TestCacheProxy::cleanup()

   129 {    

   130     delete bm;

   131     delete bmh;

   132     bm = 0;

   133     bmh = 0;

   134     

   135     delete dph;

   136     dph = 0;

   137 

   138     delete cp;

   139     cp = 0;

   140     

   141     delete cph;

   142     cph = 0;

   143 }

   144 

   145 //BufferManager

   146 void TestCacheProxy::testBM_SetPosition()

   147 {

   148     int totalsize = 100;

   149     int bufferSize = 100;

   150     bmh = new BMHelper(totalsize);

   151     bm = new HgBufferManager(bmh, bufferSize, 40, 110, totalsize);

   152     delete bmh;

   153     delete bm;

   154     

   155     totalsize = 100;

   156     bufferSize = 200;

   157     bmh = new BMHelper(totalsize);

   158     bm = new HgBufferManager(bmh, bufferSize, 40, -20, totalsize);

   159     delete bmh;

   160     delete bm;

   161 

   162     totalsize = 1000;

   163     bufferSize = 100;

   164     bmh = new BMHelper(totalsize);

   165     bm = new HgBufferManager(bmh, bufferSize, 40, 0, totalsize);

   166     

   167     QVERIFY(bmh->isIntergal(bufferSize));

   168 

   169     bm->setPosition(5);

   170     QVERIFY(bmh->isIntergal(bufferSize));

   171     

   172     bm->setPosition(23);

   173     QVERIFY(bmh->isIntergal(bufferSize));

   174 

   175     bm->setPosition(50);

   176     QVERIFY(bmh->isIntergal(bufferSize));

   177 

   178     bm->setPosition(111);

   179     QVERIFY(bmh->isIntergal(bufferSize));

   180 

   181     bm->setPosition(120);

   182     QVERIFY(bmh->isIntergal(bufferSize));

   183 

   184     bm->setPosition(130);

   185     QVERIFY(bmh->isIntergal(bufferSize));

   186     

   187     bm->setPosition(271);

   188     QVERIFY(bmh->isIntergal(bufferSize));

   189     

   190     bm->setPosition(507);

   191     QVERIFY(bmh->isIntergal(bufferSize));

   192     

   193     bm->setPosition(800);

   194     QVERIFY(bmh->isIntergal(bufferSize));

   195     

   196     bm->setPosition(880);

   197     QVERIFY(bmh->isIntergal(bufferSize));

   198     

   199     bm->setPosition(899);

   200     QVERIFY(bmh->isIntergal(bufferSize));

   201     

   202     bm->setPosition(910);

   203     QVERIFY(bmh->isIntergal(bufferSize));

   204     

   205     bm->setPosition(950);

   206     QVERIFY(bmh->isIntergal(bufferSize));

   207     

   208     bm->setPosition(996);

   209     QVERIFY(bmh->isIntergal(bufferSize));

   210     

   211     bm->setPosition(1000);

   212     QVERIFY(bmh->isIntergal(bufferSize));

   213     

   214     bm->setPosition(1200);

   215     QVERIFY(bmh->isIntergal(bufferSize));

   216     

   217     bm->setPosition(950);

   218     QVERIFY(bmh->isIntergal(bufferSize));

   219     

   220     bm->setPosition(501);

   221     QVERIFY(bmh->isIntergal(bufferSize));

   222     

   223     bm->setPosition(160);

   224     QVERIFY(bmh->isIntergal(bufferSize));

   225 

   226     bm->setPosition(150);

   227     QVERIFY(bmh->isIntergal(bufferSize));

   228 

   229     bm->setPosition(140);

   230     QVERIFY(bmh->isIntergal(bufferSize));

   231     

   232     bm->setPosition(100);

   233     QVERIFY(bmh->isIntergal(bufferSize));

   234     

   235     bm->setPosition(37);

   236     QVERIFY(bmh->isIntergal(bufferSize));

   237    

   238     bm->setPosition(1);

   239     QVERIFY(bmh->isIntergal(bufferSize));

   240     

   241     bm->setPosition(-200);

   242     QVERIFY(bmh->isIntergal(bufferSize));

   243     

   244     bm->setPosition(250);

   245     QVERIFY(bmh->isIntergal(bufferSize));

   246     

   247     bm->setPosition(-100);

   248     QVERIFY(bmh->isIntergal(bufferSize));

   249     

   250     bm->setPosition(891);

   251     QVERIFY(bmh->isIntergal(bufferSize));

   252 }

   253 

   254 void TestCacheProxy::testBM_ResetBuffer()

   255 {

   256     int totalsize = 1000;

   257     int bufferSize = 100;

   258     bmh = new BMHelper(totalsize);

   259     bm = new HgBufferManager(bmh, bufferSize, 40, 0, totalsize);

   260 

   261     bm->resetBuffer(0, totalsize);

   262     QVERIFY(bmh->isIntergal(bufferSize));

   263     

   264     bm->setPosition(891);

   265     bm->resetBuffer(0, totalsize);

   266     QVERIFY(bmh->isIntergal(bufferSize));

   267     

   268     bm->resetBuffer(880, totalsize);

   269     QVERIFY(bmh->isIntergal(bufferSize));

   270 

   271     bm->setPosition(891);

   272     bm->resetBuffer(880, totalsize);

   273     QVERIFY(bmh->isIntergal(bufferSize));

   274     

   275     bm->setPosition(999);

   276     bm->resetBuffer(0, totalsize);

   277     QVERIFY(bmh->isIntergal(bufferSize));

   278     

   279     bm->setPosition(999);

   280     bm->resetBuffer(995, totalsize);

   281     QVERIFY(bmh->isIntergal(bufferSize));

   282     

   283     bm->setPosition(10);

   284     bm->resetBuffer(910, totalsize);

   285     QVERIFY(bmh->isIntergal(bufferSize));

   286     

   287     bm->resetBuffer(10, totalsize);

   288     QVERIFY(bmh->isIntergal(bufferSize));

   289 }

   290 

   291 void TestCacheProxy::testBM_ItemCountChanged()

   292 {

   293     int totalsize = 1000;

   294     int bufferSize = 100;

   295     bmh = new BMHelper(totalsize);

   296     bm = new HgBufferManager(bmh, bufferSize, 40, 0, totalsize);    

   297     

   298     totalsize--;

   299     bmh->itemCountChanged(0, true, totalsize);

   300     bm->itemCountChanged(0, true, totalsize);

   301     QVERIFY(bmh->isIntergal(bufferSize));

   302 

   303     totalsize--;

   304     bmh->itemCountChanged(150, true, totalsize);

   305     bm->itemCountChanged(150, true, totalsize);

   306     QVERIFY(bmh->isIntergal(bufferSize));

   307 

   308     totalsize--;

   309     bm->setPosition(100);

   310     bmh->itemCountChanged(150, true, totalsize);

   311     bm->itemCountChanged(150, true, totalsize);

   312     QVERIFY(bmh->isIntergal(bufferSize));

   313 

   314     totalsize--;

   315     bm->setPosition(891);

   316     bmh->itemCountChanged(150, true, totalsize);

   317     bm->itemCountChanged(150, true, totalsize);

   318     QVERIFY(bmh->isIntergal(bufferSize));

   319     

   320     totalsize--;

   321     bm->setPosition(900);

   322     bmh->itemCountChanged(890, true, totalsize);

   323     bm->itemCountChanged(890, true, totalsize);

   324     QVERIFY(bmh->isIntergal(bufferSize));

   325     

   326     totalsize--;

   327     bm->setPosition(totalsize);

   328     bmh->itemCountChanged(totalsize, true, totalsize);

   329     bm->itemCountChanged(totalsize, true, totalsize);

   330     QVERIFY(bmh->isIntergal(bufferSize));

   331     

   332     totalsize--;

   333     bm->setPosition(totalsize+200);

   334     bmh->itemCountChanged(totalsize+200, true, totalsize);

   335     bm->itemCountChanged(totalsize+200, true, totalsize);

   336     QVERIFY(bmh->isIntergal(bufferSize));

   337     

   338     

   339     totalsize= totalsize - 10;

   340     bm->setPosition(0);

   341     bmh->itemCountChanged(0, true, totalsize);

   342     bm->itemCountChanged(0, true, totalsize);

   343     QVERIFY(bmh->isIntergal(bufferSize));

   344     

   345     totalsize= totalsize - 10;

   346     bm->setPosition(totalsize);

   347     bmh->itemCountChanged(totalsize, true, totalsize);

   348     bm->itemCountChanged(totalsize, true, totalsize);

   349     QVERIFY(bmh->isIntergal(bufferSize));

   350     

   351     totalsize= totalsize - 10;

   352     bm->setPosition(totalsize/2);

   353     bmh->itemCountChanged(totalsize/2, true, totalsize);

   354     bm->itemCountChanged(totalsize/2, true, totalsize);

   355     QVERIFY(bmh->isIntergal(bufferSize));

   356     

   357     totalsize++;

   358     bm->setPosition(0);

   359     bmh->itemCountChanged(0, false, totalsize);

   360     bm->itemCountChanged(0, false, totalsize);

   361     QVERIFY(bmh->isIntergal(bufferSize));

   362     

   363     totalsize++;    

   364     bmh->itemCountChanged(50, false, totalsize);

   365     bm->itemCountChanged(50, false, totalsize);

   366     QVERIFY(bmh->isIntergal(bufferSize));

   367     

   368     totalsize++;    

   369     bm->setPosition(100);

   370     bmh->itemCountChanged(80, false, totalsize);

   371     bm->itemCountChanged(80, false, totalsize);

   372     QVERIFY(bmh->isIntergal(bufferSize));

   373     

   374     totalsize++;    

   375     bm->setPosition(500);

   376     bmh->itemCountChanged(480, false, totalsize);

   377     bm->itemCountChanged(480, false, totalsize);

   378     QVERIFY(bmh->isIntergal(bufferSize));

   379     

   380     totalsize++;    

   381     bm->setPosition(totalsize-20);

   382     bmh->itemCountChanged(totalsize, false, totalsize);

   383     bm->itemCountChanged(totalsize, false, totalsize);

   384     QVERIFY(bmh->isIntergal(bufferSize));

   385     

   386     totalsize=totalsize+10;

   387     bm->setPosition(totalsize-20);

   388     bmh->itemCountChanged(totalsize, false, totalsize);

   389     bm->itemCountChanged(totalsize, false, totalsize);

   390     QVERIFY(bmh->isIntergal(bufferSize));

   391     

   392     totalsize=totalsize+10;

   393     bm->setPosition(20);

   394     bmh->itemCountChanged(totalsize, false, totalsize);

   395     bm->itemCountChanged(totalsize, false, totalsize);

   396     QVERIFY(bmh->isIntergal(bufferSize));

   397 

   398     totalsize=totalsize+10;

   399     bm->setPosition(totalsize/2-20);

   400     bmh->itemCountChanged(totalsize, false, totalsize);

   401     bm->itemCountChanged(totalsize, false, totalsize);

   402     QVERIFY(bmh->isIntergal(bufferSize));   

   403 }

   404 

   405 void TestCacheProxy::testBM_ResizeCache()

   406 {

   407     int totalsize = 1000;

   408     int bufferSize = 100;

   409     bmh = new BMHelper(totalsize);

   410     bm = new HgBufferManager(bmh, bufferSize, 40, 0, totalsize);

   411     

   412     bm->resizeCache(100, 40);

   413     QVERIFY(bmh->isIntergal(bufferSize));

   414     

   415     bufferSize = 50;

   416     bm->resizeCache(bufferSize, 40);

   417     QVERIFY(bmh->isIntergal(bufferSize));

   418     

   419     bufferSize = 150;

   420     bm->resizeCache(bufferSize, 50);

   421     QVERIFY(bmh->isIntergal(bufferSize));

   422     

   423     bm->setPosition(30);

   424     bm->resizeCache(bufferSize, 30);

   425     QVERIFY(bmh->isIntergal(bufferSize));

   426     

   427     bufferSize = 50;

   428     bm->resizeCache(bufferSize, 40);

   429     QVERIFY(bmh->isIntergal(bufferSize));

   430     

   431     bufferSize = 150;

   432     bm->resizeCache(bufferSize, 40);

   433     QVERIFY(bmh->isIntergal(bufferSize));

   434 

   435     bm->setPosition(500);

   436     bm->resizeCache(bufferSize, 40);

   437     QVERIFY(bmh->isIntergal(bufferSize));

   438     

   439     bufferSize = 50;

   440     bm->resizeCache(bufferSize, 40);

   441     QVERIFY(bmh->isIntergal(bufferSize));

   442     

   443     bufferSize = 151;

   444     bm->resizeCache(bufferSize, 40);

   445     QVERIFY(bmh->isIntergal(bufferSize));

   446     

   447     bm->setPosition(totalsize-20);

   448     bm->resizeCache(bufferSize, 40);

   449     QVERIFY(bmh->isIntergal(bufferSize));

   450     

   451     bufferSize = 53;

   452     bm->resizeCache(bufferSize, 40);

   453     QVERIFY(bmh->isIntergal(bufferSize));

   454     

   455     bufferSize = 150;

   456     bm->resizeCache(bufferSize, 40);

   457     QVERIFY(bmh->isIntergal(bufferSize));

   458     

   459     bm->setPosition(totalsize);

   460     bm->resizeCache(bufferSize, 40);

   461     QVERIFY(bmh->isIntergal(bufferSize));

   462     

   463     bufferSize = 50;

   464     bm->resizeCache(bufferSize, 40);

   465     QVERIFY(bmh->isIntergal(bufferSize));

   466     

   467     bufferSize = 175;

   468     bm->resizeCache(bufferSize, 40);

   469     QVERIFY(bmh->isIntergal(bufferSize));

   470 }

   471 

   472 //DataProvider

   473 void TestCacheProxy::testDP_QAbstractItemModel()

   474 {

   475     dph = new DataProviderHelper();

   476     delete dph;

   477     dph = new DataProviderHelper(200);

   478     testQAbstractItemModel(dph, 200, 1);

   479 }

   480 

   481 void TestCacheProxy::testDP_RequestReleaseAndData()

   482 {

   483     dph = new DataProviderHelper();

   484     QModelIndex idx = dph->index(0,0);

   485     QVariant res = dph->data(idx, Qt::DisplayRole);

   486     QVERIFY(res.isValid() == true);

   487     QString s = res.toString(); 

   488     QVERIFY(s.isNull() == false);

   489 

   490     res = dph->data(idx, Qt::UserRole+1); //int value (not less then 0)

   491     QVERIFY(res.isValid() == true);

   492     QVERIFY(res.toInt() >= 0);

   493     

   494     res = dph->data(idx, Qt::UserRole+100); //should be empty

   495     QVERIFY(res.isValid() == false);

   496 

   497     res = dph->data(idx, Qt::DecorationRole); //should give defaultIcon();

   498     QVERIFY(res.isValid() == true);

   499     s = res.toString(); 

   500     QVERIFY(s.isNull() == false);

   501     QVERIFY(res == dph->defaultIcon());

   502 

   503     idx = dph->index(-10, 0);

   504     res = dph->data(idx, Qt::DisplayRole);

   505     QVERIFY(res.isValid() == false);

   506 

   507     idx = dph->index(1000000, 0);

   508     res = dph->data(idx, Qt::DisplayRole);

   509     QVERIFY(res.isValid() == false);

   510 

   511     QList<int> list;

   512     list<<-1;

   513     list<<0;

   514     list<<1;

   515     list<<2;

   516     list<<1000000;

   517     dph->registerObserver(dph);

   518     dph->request(list);

   519     QList< QPair< int, int > > updates = dph->getObserverDataUpdated();

   520     QVERIFY(updates.count() == 3); //3 updates - for 0 1 and 2

   521     QVERIFY(updates[0].first == 0); //for 0

   522     QVERIFY(updates[0].second == 0); //for 0

   523     QVERIFY(updates[1].first == 1); //for 1

   524     QVERIFY(updates[1].second == 1); //for 1

   525     QVERIFY(updates[2].first == 2); //for 2

   526     QVERIFY(updates[2].second == 2); //for 2

   527     

   528     idx = dph->index(0,0);

   529     res = dph->data(idx, Qt::DecorationRole);

   530     QVERIFY(res.isValid() == true);

   531     s = res.toString(); 

   532     QVERIFY(s.isNull() == false);

   533     s = QString("MyNiceIcon %1").arg(0);

   534     QVERIFY(res.toString() == s);

   535 

   536     idx = dph->index(1,0);

   537     res = dph->data(idx, Qt::DecorationRole);

   538     QVERIFY(res.isValid() == true);

   539     s = res.toString(); 

   540     QVERIFY(s.isNull() == false);

   541     s = QString("MyNiceIcon 1");

   542     QVERIFY(res.toString() == s);

   543     

   544     idx = dph->index(2,0);

   545     res = dph->data(idx, Qt::DecorationRole);

   546     QVERIFY(res.isValid() == true);

   547     s = res.toString(); 

   548     QVERIFY(s.isNull() == false);

   549     s = QString("MyNiceIcon 2");

   550     QVERIFY(res.toString() == s);

   551     

   552     idx = dph->index(3,0);

   553     res = dph->data(idx, Qt::DecorationRole);

   554     QVERIFY(res.isValid() == true);

   555     s = res.toString(); 

   556     QVERIFY(s.isNull() == false);

   557     s = QString("MyNiceIcon 3");

   558     QVERIFY(res.toString() != s);

   559     QVERIFY(res == dph->defaultIcon());    

   560     

   561     dph->release(list, false);

   562     updates = dph->getObserverDataUpdated();

   563     QVERIFY(updates.count() == 0); //0 updates - updates from emit not observer

   564     updates = dph->getSignalDataUpdated();

   565     QVERIFY(updates.count() == 1); //1 update for all items

   566     QVERIFY(updates[0].first == 0); //for 0

   567     QVERIFY(updates[0].second == 2); //for 0

   568     

   569     idx = dph->index(0, 0);

   570     res = dph->data(idx, Qt::DecorationRole);

   571     QVERIFY(res == dph->defaultIcon());    

   572 

   573     idx = dph->index(1, 0);

   574     res = dph->data(idx, Qt::DecorationRole);

   575     QVERIFY(res == dph->defaultIcon());    

   576 

   577     idx = dph->index(2, 0);

   578     res = dph->data(idx, Qt::DecorationRole);

   579     QVERIFY(res == dph->defaultIcon());    

   580     

   581     idx = dph->index(3, 0);

   582     res = dph->data(idx, Qt::DecorationRole);

   583     QVERIFY(res == dph->defaultIcon());    

   584     dph->registerObserver(NULL);

   585     dph->request(list);

   586     updates = dph->getObserverDataUpdated();

   587     QVERIFY(updates.count() == 0); //0 updates - no observer

   588     dph->getSignalDataUpdated();

   589     dph->release(list, false);

   590     updates = dph->getObserverDataUpdated();

   591     QVERIFY(updates.count() == 0); //0 updates - no observer

   592 }

   593 

   594 void TestCacheProxy::testDP_CacheManagment()

   595 {

   596     dph = new DataProviderHelper(100);

   597     //signals status reset

   598     dph->getObserverDataUpdated();

   599     dph->getSignalDataUpdated();

   600     dph->getSignalRowsAboutToBeInserted();    

   601     dph->getSignalRowsInserted();

   602     dph->getSignalRowsAboutToBeRemoved();    

   603     dph->getSignalRowsRemoved();

   604     dph->getSignalAboutToBeReset();

   605     dph->getSignalReset();

   606     

   607     int size = dph->rowCount();

   608     QModelIndex idx;

   609     QVariant res;

   610     for ( int i=0; i<size; i++){

   611         idx = dph->index(i,0);

   612         res = dph->data(idx, Qt::UserRole+1);

   613         QVERIFY(res.isValid() == true);

   614         QVERIFY(res.toInt() == i);   

   615     }

   616     idx = dph->index(0,0);

   617     dph->testClearCache();    

   618     res = dph->data(idx, Qt::DisplayRole);

   619     QVERIFY(res.isValid() == false);

   620     

   621     QList< QPair< QVariant, int > > list;

   622     QString s = "NEWITEM";

   623     list.append( QPair< QVariant, int >(s, Qt::DisplayRole) );

   624     

   625     dph->testUpdate(0, &list, false); //update shouldn't change - no item

   626     dph->testUpdate(-1, &list, true); //update shouldn't change - no item

   627     dph->testUpdate(120000, &list, false); //update shouldn't change - no item

   628     res = dph->data(idx, Qt::DisplayRole);

   629     QVERIFY(res.isValid() == false);

   630     QVERIFY(dph->getObserverDataUpdated().count() == 0);

   631 

   632     dph->testNewItem(&list, false);

   633     QList< QPair< int, int > > resList = dph->getSignalRowsAboutToBeInserted();

   634     QVERIFY(resList.count() == 1);

   635     QVERIFY(resList[0].first == 0); //for item 0

   636     QVERIFY(resList[0].second == 0); //for item 0

   637     resList = dph->getSignalRowsInserted();

   638     QVERIFY(resList.count() == 1);

   639     QVERIFY(resList[0].first == 0); //for item 0

   640     QVERIFY(resList[0].second == 0); //for item 0

   641     

   642     QVERIFY(dph->rowCount() == 1);

   643     

   644     idx = dph->index(0,0);

   645     res = dph->data(idx, Qt::DisplayRole);

   646     QVERIFY(res.isValid() == true);

   647     QVERIFY(res == s);

   648     dph->testNewItem(&list, true);

   649     QVERIFY(dph->getSignalRowsAboutToBeInserted().count() == 0);//no updates it was suuposed to be silent

   650     QVERIFY(dph->getSignalRowsInserted().count() == 0);//no updates it was suuposed to be silent    

   651     QVERIFY(dph->rowCount() == 2);

   652 

   653     dph->testNewItem(&list, false);

   654     dph->testNewItem(&list, false);

   655     resList = dph->getSignalRowsInserted();

   656     QVERIFY(resList.count() == 2);

   657     QVERIFY(resList[0].first == 2); //for item 2

   658     QVERIFY(resList[0].second == 2); //for item 2

   659     QVERIFY(resList[1].first == 3); //for item 3

   660     QVERIFY(resList[1].second == 3); //for item 3

   661 

   662     list.clear();

   663     QString s2 = "NEWITEM2";

   664     list.append( QPair< QVariant, int >(s2, Qt::DisplayRole) );

   665     dph->testUpdate(0, &list, false);

   666     resList = dph->getSignalDataUpdated();

   667     QVERIFY(resList.count() == 1);

   668     QVERIFY(resList[0].first == 0);

   669     QVERIFY(resList[0].second == 0);

   670     res = dph->data(idx, Qt::DisplayRole);

   671     QVERIFY(res.isValid() == true);

   672     QVERIFY(res == s2);

   673     

   674     dph->testRemoveItems(0, 1);//should remove item

   675     resList = dph->getSignalRowsAboutToBeRemoved();

   676     QVERIFY(resList.count() == 1);

   677     QVERIFY(resList[0].first == 0);

   678     QVERIFY(resList[0].second == 0);

   679     resList = dph->getSignalRowsRemoved();

   680     QVERIFY(resList.count() == 1);

   681     QVERIFY(resList[0].first == 0);

   682     QVERIFY(resList[0].second == 0);

   683     

   684     QVERIFY(dph->rowCount() == 3);

   685     dph->testRemoveItems(-2, 10);//should remove remaining items (0,1, 2)

   686     resList = dph->getSignalRowsAboutToBeRemoved();

   687     QVERIFY(resList.count() == 1);

   688     QVERIFY(resList[0].first == 0);

   689     QVERIFY(resList[0].second == 2);

   690 

   691     QVERIFY(dph->rowCount() == 0);

   692     idx = dph->index(0,0);

   693     res = dph->data(idx, Qt::DisplayRole); //invalid variant, for not existing item

   694     QVERIFY(res.isValid() == false);

   695     

   696     QVERIFY(dph->getSignalAboutToBeReset() == false);

   697     QVERIFY(dph->getSignalReset() == false);    

   698     dph->resetModel();

   699     QVERIFY(dph->getSignalAboutToBeReset() == true);

   700     QVERIFY(dph->getSignalReset() == true);

   701     QVERIFY(dph->columnCount() == 1);

   702     QVERIFY(dph->rowCount() == 1000);

   703     idx = dph->index(0,0);

   704     res = dph->data(idx, Qt::DisplayRole);

   705     QVERIFY(res.isValid() == true);

   706     QVERIFY(res.toString().startsWith(QString("NEW ITEM")) == true);    

   707     

   708     dph->testRemoveItems(0, 100);//should remove items 0 - 99

   709     QVERIFY(dph->rowCount() == 900);

   710     idx = dph->index(0,0);

   711     res = dph->data(idx, Qt::UserRole+1);

   712     QVERIFY(res.isValid() == true);

   713     QVERIFY(res.toInt() == 100);

   714     

   715     dph->testUpdate(0, QString(""), Qt::DisplayRole, false);

   716     idx = dph->index(0,0);

   717     res = dph->data(idx, Qt::DisplayRole);

   718     QVERIFY(res.isValid() == true);

   719     QVERIFY(res.toString() == QString(""));    

   720 

   721     resList = dph->getSignalDataUpdated();

   722     QVERIFY(resList.count() == 1);

   723     QVERIFY(resList[0].first == 0);

   724     QVERIFY(resList[0].second == 0);

   725     

   726     dph->testNewItem( QPair< QVariant, int >(QString(""), Qt::DisplayRole), false);

   727     resList = dph->getSignalRowsInserted();

   728     QVERIFY(resList.count() == 1);

   729     QVERIFY(resList[0].first == dph->rowCount()-1);

   730     QVERIFY(resList[0].second == dph->rowCount()-1);

   731     

   732     dph->getSignalRowsInserted();

   733     dph->getSignalRowsRemoved();

   734     dph->testInsertItem(100, QPair< QVariant, int >(QString(""), Qt::DisplayRole), false);

   735     resList = dph->getSignalRowsInserted();

   736     QVERIFY(resList.count() == 1);

   737     QVERIFY(resList[0].first == 100);

   738     QVERIFY(resList[0].second == 100);

   739     dph->testRemoveItem(100);

   740     resList = dph->getSignalRowsRemoved();

   741     QVERIFY(resList.count() == 1);

   742     QVERIFY(resList[0].first == 100);

   743     QVERIFY(resList[0].second == 100); 

   744     

   745     dph->getSignalRowsInserted();

   746     dph->getSignalRowsRemoved();

   747     dph->testInsertItem(-10, QPair< QVariant, int >(QString(""), Qt::DisplayRole), false); //insert with -10 puts it at begining

   748     resList = dph->getSignalRowsInserted();

   749     QVERIFY(resList.count() == 1);

   750     QVERIFY(resList[0].first == 0);

   751     QVERIFY(resList[0].second == 0);

   752     dph->testRemoveItem(-10);

   753     resList = dph->getSignalRowsRemoved();

   754     QVERIFY(resList.count() == 0);

   755 

   756     dph->getSignalRowsInserted();

   757     dph->getSignalRowsRemoved();

   758     dph->testInsertItem(100000, QPair< QVariant, int >(QString(""), Qt::DisplayRole), false); //insert with beyond range puts it at end

   759     resList = dph->getSignalRowsInserted();

   760     QVERIFY(resList.count() == 1);

   761     QVERIFY(resList[0].first == dph->rowCount()-1);

   762     QVERIFY(resList[0].second == dph->rowCount()-1);    

   763     dph->testRemoveItem(100000);

   764     resList = dph->getSignalRowsRemoved();

   765     QVERIFY(resList.count() == 0);

   766     

   767     idx = dph->index(579,0);

   768     QMap<int, QVariant> it = dph->itemData(idx);

   769     QCOMPARE(it.size(), 4);

   770     QCOMPARE(it.contains(Qt::DisplayRole), true);

   771     QVariant r2 = it[Qt::DisplayRole];

   772     QCOMPARE(r2.isValid(), true);

   773     res = dph->data(idx, Qt::DisplayRole);

   774     QCOMPARE(res.isValid(), true);

   775     QCOMPARE(res.toString(), r2.toString());

   776     

   777 }

   778 

   779 void TestCacheProxy::testDP_QPixmapPool()

   780 {

   781     dph = new DataProviderHelper(100);

   782     QPixmap pix;

   783     QVariant res = dph->testCreateIcon(0, pix);

   784     QVERIFY(res.isValid() == false);

   785 

   786     dph->resizeQPixmapPool(10);

   787     

   788     res = dph->testCreateIcon(0, pix);

   789     QVERIFY(res.isValid() == true);

   790     QVERIFY(res != dph->defaultIcon());

   791     

   792     QVariant res2 = dph->testCreateIcon(0, pix);

   793     QVERIFY(res2.isValid() == true);

   794     QVERIFY(res != dph->defaultIcon());   

   795 

   796     dph->testCreateIcon(0, pix);

   797     dph->testCreateIcon(1, pix);

   798     dph->testCreateIcon(2, pix);    

   799     dph->testCreateIcon(3, pix);

   800     dph->testCreateIcon(4, pix);

   801     

   802     dph->testReleasePixmap(-10);

   803     dph->testReleasePixmap(4);

   804     dph->testReleasePixmap(5);

   805     dph->testReleasePixmap(200);

   806     dph->resizeQPixmapPool(20);

   807     dph->resizeQPixmapPool(5);

   808     dph->testReleasePixmap(100);

   809     dph->resizeQPixmapPool(100);

   810     dph->resizeQPixmapPool(2);

   811     dph->testReleasePixmap(1);

   812     dph->testReleasePixmap(2);

   813     dph->testReleasePixmap(3);

   814     dph->testReleasePixmap(4);

   815     dph->testCreateIcon(1, pix);

   816     dph->testCreateIcon(2, pix);

   817     dph->testCreateIcon(3, pix);

   818     dph->testCreateIcon(4, pix);

   819     dph->testCreateIcon(6, pix);

   820     dph->resizeQPixmapPool(1);

   821     res = dph->testCreateIcon(10, pix);

   822     QVERIFY(res.isValid() == false);    

   823 }

   824 

   825 void TestCacheProxy::testCP_QAbstractItemModel()

   826 {

   827     cp = new HgCacheProxyModel();

   828     dph = new DataProviderHelper(200);

   829     testQAbstractItemModel(cp, 0, 0);

   830 

   831     cp->setDataProvider(dph);

   832     QVERIFY(cp->DataProvider() == dph);

   833     testQAbstractItemModel(cp, 200, 1);

   834     cp->setDataProvider(0);

   835     QVERIFY(cp->DataProvider() == 0);

   836 }

   837 

   838 void TestCacheProxy::testCP_SignalsForward()

   839 {

   840     cp = new HgCacheProxyModel();

   841     cph = new CacheProxyHelper(cp);

   842     dph = new DataProviderHelper(200);    

   843     cp->setDataProvider(dph, 50, 20);

   844     

   845     QList< QPair< int, int > > resList = cph->getSignalDataChanged();

   846     QVERIFY(resList.count() == 50);

   847     QVERIFY(resList[0].first == 0);

   848     QVERIFY(resList[0].second == 0);

   849     QVERIFY(resList[49].first == 49);

   850     QVERIFY(resList[49].second == 49);

   851     

   852     QList< QPair< QVariant, int > > list;

   853     QString s = "NEWITEM";

   854     list.append( QPair< QVariant, int >(s, Qt::DisplayRole) );

   855 

   856     dph->testNewItem(&list, false);

   857     resList = cph->getSignalRowsAboutToBeInserted();

   858     QVERIFY(resList.count() == 1);

   859     QVERIFY(resList[0].first == dph->rowCount()-1);

   860     QVERIFY(resList[0].second == dph->rowCount()-1);

   861     resList = cph->getSignalRowsInserted();

   862     QVERIFY(resList.count() == 1);

   863     QVERIFY(resList[0].first == dph->rowCount()-1);

   864     QVERIFY(resList[0].second == dph->rowCount()-1);

   865     

   866     dph->testRemoveItems(0, 1);//should remove item

   867     resList = cph->getSignalRowsAboutToBeRemoved();

   868     QVERIFY(resList.count() == 1);

   869     QVERIFY(resList[0].first == 0);

   870     QVERIFY(resList[0].second == 0);

   871     resList = cph->getSignalRowsRemoved();

   872     QVERIFY(resList.count() == 1);

   873     QVERIFY(resList[0].first == 0);

   874     QVERIFY(resList[0].second == 0);

   875     

   876     cph->getSignalModelAboutToBeReset();

   877     cph->getSignalModelReset();

   878     dph->resetModel();

   879     QVERIFY(cph->getSignalModelAboutToBeReset() == true);

   880     QVERIFY(cph->getSignalModelReset() == true);

   881     QVERIFY(cp->columnCount() == 1);

   882     QVERIFY(cp->rowCount() == 1000);

   883 

   884 }

   885 

   886 void TestCacheProxy::testCP_ResizeCache()

   887 {

   888     cp = new HgCacheProxyModel();

   889     cph = new CacheProxyHelper(cp);

   890     dph = new DataProviderHelper(200);

   891     cp->setDataProvider(dph, 50, 20);

   892     dph->getLastRelease();

   893     dph->getLastRequest();

   894     cp->resizeCache(20, 5);

   895     

   896     QList<int> l = dph->getLastRelease();

   897     QVERIFY(l.count() > 0);

   898     l = dph->getLastRequest();

   899     QVERIFY(l.count() == 0);

   900     

   901     dph->getLastRelease();

   902     dph->getLastRequest();

   903     cp->resizeCache(100, 5);

   904     dph->getLastRelease();

   905     QVERIFY(l.count() == 0);

   906     l = dph->getLastRequest();

   907     QVERIFY(l.count() > 0);

   908 }

   909 

   910 void TestCacheProxy::testCP_Data()

   911 {

   912     cp = new HgCacheProxyModel();

   913     cph = new CacheProxyHelper(cp);

   914     dph = new DataProviderHelper(200);

   915     cp->setDataProvider(dph, 50, 20);

   916     dph->getLastRelease();

   917     dph->getLastRequest();

   918     

   919     QModelIndex idx = cp->index(0, 0);

   920     QVariant res = cp->data(idx, Qt::UserRole+1);

   921     QCOMPARE(res.isValid(), true);

   922     QCOMPARE(res.toInt(), 0);

   923     

   924     idx = cp->index(100, 0);

   925     res = cp->data(idx, Qt::UserRole+1);

   926     QCOMPARE(res.isValid(), true);

   927     QCOMPARE(res.toInt(), 100);

   928     

   929     idx = cp->index(101, 0);

   930     res = cp->data(idx, Qt::UserRole+1);

   931     QCOMPARE(res.isValid(), true);

   932     QCOMPARE(res.toInt(), 101);

   933 

   934     idx = cp->index(50, 0);

   935     res = cp->data(idx, Qt::UserRole+1);

   936     QCOMPARE(res.isValid(), true);

   937     QCOMPARE(res.toInt(), 50);

   938     

   939     idx = cp->index(40, 0);

   940     res = cp->data(idx, Qt::UserRole+1);

   941     QCOMPARE(res.isValid(), true);

   942     QCOMPARE(res.toInt(), 40);

   943     

   944     idx = cp->index(35, 0);

   945     res = cp->data(idx, Qt::UserRole+1);

   946     QCOMPARE(res.isValid(), true);

   947     QCOMPARE(res.toInt(), 35);

   948     

   949     idx = cp->index(25, 0);

   950     res = cp->data(idx, Qt::UserRole+1);

   951     QCOMPARE(res.isValid(), true);

   952     QCOMPARE(res.toInt(), 25);

   953     

   954     int v = 234234;

   955     res = QVariant(v);

   956     idx = cp->index(0, 0);

   957     cp->setData(idx, res, Qt::UserRole+1);

   958     res = cp->data(idx, Qt::UserRole+1);

   959     QCOMPARE(res.isValid(), true);

   960     QCOMPARE(res.toInt(), v);

   961     

   962     QMap<int, QVariant> map = cp->itemData(idx);

   963     QCOMPARE(map.size(), 5);

   964     map[v]=v;

   965     cp->setItemData(idx, map);

   966     res = cp->data(idx, v);

   967     QCOMPARE(res.isValid(), true);

   968     QCOMPARE(res.toInt(), v);

   969 

   970     

   971 }

   972 

   973 void TestCacheProxy::testCP_Sort()

   974 {

   975     cp = new HgCacheProxyModel();

   976     cph = new CacheProxyHelper(cp);

   977     dph = new DataProviderHelper(200);

   978     cp->setDataProvider(dph, 50, 20);

   979 

   980     cp->setSortRole(Qt::UserRole+2);

   981     QCOMPARE(cp->sortRole(), Qt::UserRole+2);

   982     cp->sort(0, Qt::AscendingOrder);

   983     QCOMPARE(cp->sortColumn(), 0);

   984     QCOMPARE(cp->sortOrder(), Qt::AscendingOrder);

   985     

   986     QModelIndex idx = cp->index(10, 0);

   987     QVariant res = cp->data(idx, Qt::UserRole+2);

   988     QCOMPARE(res.isValid(), true);

   989     QCOMPARE(res.toInt(), -(cp->rowCount(idx) -1 -10));

   990     res = cp->data(idx, Qt::UserRole+1);

   991     QCOMPARE(res.isValid(), true);

   992     QCOMPARE(res.toInt(), cp->rowCount(idx) -1 -10);

   993     

   994     idx = cp->index(50, 0);

   995     res = cp->data(idx, Qt::UserRole+2);

   996     QCOMPARE(res.isValid(), true);

   997     QCOMPARE(res.toInt(), -(cp->rowCount(idx) -1 -50));

   998     res = cp->data(idx, Qt::UserRole+1);

   999     QCOMPARE(res.isValid(), true);

  1000     QCOMPARE(res.toInt(), cp->rowCount(idx) -1 -50);

  1001     

  1002     cp->setSortRole(Qt::DisplayRole);

  1003     cp->setSortCaseSensitivity(Qt::CaseSensitive);

  1004     QCOMPARE(cp->sortCaseSensitivity(), Qt::CaseSensitive);

  1005     cp->sort(0, Qt::AscendingOrder);

  1006     

  1007     idx = cp->index(10, 0);

  1008     res = cp->data(idx, Qt::UserRole+1);

  1009     QCOMPARE(res.isValid(), true);

  1010     QCOMPARE(res.toInt()%2, 0);

  1011     

  1012     idx = cp->index(110, 0);

  1013     res = cp->data(idx, Qt::UserRole+1);

  1014     QCOMPARE(res.isValid(), true);

  1015 //    qWarning("i=%d",res.toInt());

  1016     QCOMPARE(res.toInt()%2, 1);

  1017     

  1018     cp->setSortLocaleAware(true);

  1019     QCOMPARE(cp->isSortLocaleAware(), true);

  1020     cp->setSortLocaleAware(false);

  1021     QCOMPARE(cp->isSortLocaleAware(), false);

  1022         

  1023     QString s = QString("AAA");

  1024     cp->setDynamicSortFilter(true);

  1025     QCOMPARE(cp->dynamicSortFilter(), true);

  1026     cp->setSortRole(Qt::DisplayRole);

  1027     cp->setSortCaseSensitivity(Qt::CaseSensitive);

  1028     dph->testInsertItem(10, QPair< QVariant, int >(s, Qt::DisplayRole), false);

  1029     idx = cp->index(0, 0);

  1030     res = cp->data(idx, Qt::DisplayRole);

  1031     QCOMPARE(res.isValid(), true);

  1032 //    qWarning()<<res.toString();

  1033     QCOMPARE(res.toString(), s);

  1034     

  1035 }

  1036 

  1037 //void TestCacheProxy::testCP_Filter()

  1038 //{

  1039 //    cp = new HgCacheProxyModel();

  1040 //    cph = new CacheProxyHelper(cp);

  1041 //    dph = new DataProviderHelper(200);

  1042 //    cp->setDataProvider(dph, 50, 20);

  1043 //

  1044 //    QModelIndex idx = cp->index(1, 0);

  1045 //    QVariant res = cp->data(idx, Qt::DisplayRole);

  1046 //    QCOMPARE(res.isValid(), true);

  1047 //    QCOMPARE(res.toString().startsWith("item"), true);

  1048 //    

  1049 //    QRegExp regexp = QRegExp("ITEM*", Qt::CaseSensitive, QRegExp::Wildcard);

  1050 //    

  1051 //    cp->setFilterRegExp(regexp);

  1052 //    QVERIFY(cp->filterRegExp() == regexp);

  1053 //    cp->setFilterCaseSensitivity(Qt::CaseSensitive);

  1054 //    QCOMPARE(cp->filterCaseSensitivity(), Qt::CaseSensitive);   

  1055 //    

  1056 //    idx = cp->index(1, 0);

  1057 //    res = cp->data(idx, Qt::DisplayRole);

  1058 //    QCOMPARE(res.isValid(), true);

  1059 //    QCOMPARE(res.toString().startsWith("item"), false);

  1060 //    

  1061 //    cp->setFilterKeyColumn(1);

  1062 //    QCOMPARE(cp->filterKeyColumn (), 1);

  1063 //    cp->setFilterKeyColumn(0);

  1064 //    

  1065 //    cp->setFilterRole(Qt::UserRole+1);

  1066 //    QCOMPARE(cp->filterRole(), Qt::UserRole+1);

  1067 //    cp->setFilterRole(Qt::DisplayRole);     

  1068 //    

  1069 //    regexp = QRegExp("ITEM*", Qt::CaseInsensitive, QRegExp::Wildcard);

  1070 //    cp->setFilterRegExp(regexp);

  1071 //    QVERIFY(cp->filterRegExp() == regexp);

  1072 //    cp->setFilterCaseSensitivity(Qt::CaseInsensitive);

  1073 //    QCOMPARE(cp->filterCaseSensitivity(), Qt::CaseInsensitive);   

  1074 //

  1075 //    idx = cp->index(1, 0);

  1076 //    res = cp->data(idx, Qt::DisplayRole);

  1077 //    QCOMPARE(res.isValid(), true);

  1078 //    QCOMPARE(res.toString().startsWith("item"), true);

  1079 //

  1080 //}

  1081 

  1082 

  1083 #ifdef _CACHEPROXYDATAMODEL_UNITTEST_LOG_TO_C

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

  1085     {

  1086         QApplication app(argc, argv);

  1087         TestCacheProxy tc;

  1088         int c = 3;

  1089         char* v[] = {argv[0], "-o", "c:/test.txt"};

  1090         return QTest::qExec(&tc, c, v);

  1091     }

  1092 #else

  1093     QTEST_MAIN(TestCacheProxy)

  1094 #endif